Learning Roadmap & Common Mistakes
The step-by-step path from basics to your first real agent, mapped onto this course — plus the beginner mistakes that waste the most time, and how to dodge each one.
The roadmap
The classic beginner path — with the exact place in this course where each step happens.
-
Learn the basics
What agents are, the building blocks, the loop, LLM-vs-agent. Build the mental model before writing code.
→ Ch 0 · Foundations (you're basically here) -
Learn to use the tools
Make real API calls, control the model, get reliable structured output back. The raw materials of every agent.
→ Ch 1 · First call + Ch 2 · Prompting & structured output -
Build a small project
Ground the model in real data (RAG), then give it tools and a loop (agent). Start with one simple, working thing.
→ Ch 3 · RAG + Ch 4 · Agent -
Test & improve
Measure quality with evals so you can prove a change helped. This is how you earn the trust to remove the human.
→ Ch 5 · Evaluation -
Ship & harden
Caching, observability, guardrails, deployment — turn the prototype into a background service you can rely on.
→ Ch 6 · Production hardening
Common mistakes to avoid
Trying to build the fully-autonomous dream on day one.
✓ Fix: solve one simple slice first, then grow it. (Ch 0 scoping rules.)Fuzzy instructions → fuzzy, inconsistent behavior.
✓ Fix: the 5-part prompt + examples. (Ch 2.)Shipping on "seems fine," then quality silently drifts.
✓ Fix: an eval harness + regression gate. (Ch 5.)Jumping to agents without understanding one API call.
✓ Fix: do Ch 1–2 before Ch 4. The loop is just many calls.Letting the agent take irreversible actions unchecked.
✓ Fix: approval gates on risky steps. (Ch 4 & 6.)The three mantras
- Start simple. The smallest thing that works, then iterate.
- Test everything. If you can't measure it, you can't trust it.
- Keep a human in the loop until the evals say you don't need one.
The capstone — your AI DevOps Engineer
This course's destination is Part V: Ch 7 teaches the Forward Deployed Engineer method, and Ch 8 assembles everything you've built into one advanced project — an AI DevOps Engineer that onboards into any company (Git/GitLab, Terraform, Kubernetes/EKS, AWS, Docker, Jenkins, CI/CD, Argo CD, Python) and can even be hired on subscription. Same "start simple → test → increase autonomy" discipline, applied to infrastructure:
This staircase is the whole plan for the course's final project (the capstone), drawn as a ladder of trust. Read it left-to-right and bottom-to-top: each box is a stage where you let the AI agent do a little more on its own, and each step up is only unlocked once you've proven the step below is safe. You climb one rung at a time — you never jump straight to the top.
- The four boxes are the rungs, and they get higher as you go right — that rising height is the picture's way of saying "more freedom, more responsibility." Rung 1 · Observe is the safest: the agent only looks and reports what's wrong (it "reads diagnosis"), changing nothing.
- 2 · Recommend: the agent now suggests fixes but a human still checks each one — the label underneath says it "reviews every PR" (a PR is a proposed code change someone must approve before it takes effect).
- 3 · Act (gated): the agent is allowed to actually do reversible things (like restarting something), but only after a human clicks approve — "approves each action." "Gated" means a gate/checkpoint stands in front of every action.
- 4 · Selective: the top rung — a short, pre-approved list of safe actions runs on its own, but the red note "prod stays gated" warns that the real live production system still always needs a human. That red colour is a deliberate warning.
- The short diagonal arrows between the boxes are the climb — you move up only in order, and the caption's rule tells you what powers each climb: "each rung unlocks only when evals prove the previous one safe." Evals are automated quality tests (you'll meet them in Ch 5); passing them is your evidence to earn the next rung.
- Notice this mirrors the numbered roadmap higher up the page. The 5-step path (learn basics → learn the tools → build a small project → test & improve → ship & harden) is the same idea in words: start tiny and safe, measure, then grow. This ladder just applies it to how much you trust the agent.
In short: don't read this as "steps to full automation." It's a trust ladder — you spend evidence from tests to buy one more rung of freedom at a time, and the very top of production stays human-approved on purpose. Start at Observe, prove it, then climb.
| Phase | Goal | Human role | Uses |
|---|---|---|---|
| 0 · Prep | Finish this course. Brush up your DevOps tools (you already know most). | — | All chapters |
| 1 · Observe | Agent diagnoses incidents read-only across K8s/AWS/CI; answers "how do we do X here?" | Reads the diagnosis | Ch 2, 3, 4 |
| 2 · Recommend | Agent opens PRs/MRs: fixes, Terraform, Dockerfiles, pipeline repairs. | Reviews every PR | Ch 4, 6 |
| 3 · Act w/ approval | Executes gated reversible ops (scale, restart, sync/rollback) on one-click approval. | Approves each action | Ch 5 (evals gate it) |
| 4 · Selective autonomy | A short allowlist of proven-safe non-prod ops run unattended; prod stays gated. | Exceptions only | Ch 6 |
terraform apply on prod is not the goal — a copilot that turns an hour of toil into a 60-second PR review is. Autonomy is earned per-operation, on evidence from evals.Diagnosis prompt. We'll build it the FDE way: thin, safe, end-to-end.