AI Engineering Roadmap: Operating AI Coding Agents¶

Search for an "AI engineering roadmap" and almost every result teaches the same path: Python, statistics, deep learning, transformers, retrieval, fine-tuning. That is the roadmap to building models, and it is the right one if your goal is to become a machine-learning engineer.

This is the other roadmap. It is for engineers who can already write and ship code and need the skill that actually shows up in the job now: getting reliable work out of an AI coding agent you did not build. The two are complementary, and most engineers shipping with agents today need this one first. It lays out the order in which the operator moves build on each other — read the agent's behavior, give it the right context, specify the work, verify what it returns, shape its tools, run several at once, fold the practice into real delivery, and judge when an agent is the wrong tool. Each stage links to the lesson that teaches it. The sequence is the opinion here: the order a senior engineer can actually absorb, where every stage closes a gap the previous one left open.

The roadmap¶

Every card is a lesson; the text below walks the same path in order, so you can follow it without the diagram.

Stage 0 — Foundations: the operator's model¶

Before any technique, you need a working picture of what the agent is doing when it runs, because every later move is a response to one of its failure modes. Module 0 · The Agent Loop teaches you to read a session: to see when the agent has lost the thread, when it is editing plausibly but wrongly, and when it is thrashing. Without that read, the rest of the roadmap is a list of tricks with no signal for when to apply them.

Stage 1 — The Core Craft: drive an agent well¶

This is the center of the work, and the three lessons stack in order.

Module 1 · Context Engineering is the central skill: deciding what the agent sees, so it opens the right file and follows your conventions on its own. It is where your CLAUDE.md comes from.
Module 2 · Specification turns a vague request into a deliverable the agent can execute against — a clear statement of what "done" means, so you are grading against a target rather than reacting to whatever it produced.
Module 3 · Verification and Guardrails is the trust layer: the machinery that checks output you did not write, so a passing change is one you can actually believe. It continues into eval-driven development and guardrails that bound the blast radius.

By the end of this stage you can hand an agent a real task, give it what it needs, and confirm the result without reading every line yourself.

Stage 2 — Extending and Scaling: multiply yourself¶

Once you can drive one agent reliably, the next gap is leverage.

Module 4 · Shaping the Agent Harness covers the tools, skills, and permissions you give the agent so it can do more without you stepping in for each step.
Module 5 · Orchestration is how you run several agents at once — slicing work so the pieces do not collide, and reviewing the combined output — without losing control of any of them.

Stage 3 — Integration and Judgment: make it pay off¶

A skill you use in a sandbox is not yet a working practice.

Module 6 · Compound Engineering folds the moves into real delivery so each task makes the next one cheaper, and leaves your own codebase navigable to an agent.
Module 7 · Judgment and Economics is where you learn the limits: the unit cost of agent work, and when the honest call is to write the code by hand.

Capstone¶

Module 8 · Drive a Real Change End-to-End applies every prior stage to one real change in your own repository, start to finish. It is the proof that you can operate an agent the way a tech lead operates a strong, fast engineer who still needs direction.

Two roadmaps wear this name¶

If you arrived here looking for the path to building AI systems — model architecture, retrieval pipelines, training and fine-tuning — that is the other roadmap, and the course is explicit about the boundary. It does not teach what a large language model is or how a transformer works. It teaches the operating skill that sits on top of those systems: getting reliable work out of an agent you did not build. If you can already code and your goal is to ship with agents rather than to train them, this operator roadmap is the one to follow first.

Where to start¶

Begin at Module 0 and work down the stages in order; each one assumes the one above it. Every lesson runs on a shared Practice Repo with known answers before you take the move to your own codebase, and the running index of what you build along the way is Your Toolkit.