The Agentic Engineering Curriculum
This is a course, not an essay. Twelve lessons take you from first principles to running agentic software delivery, and every lesson links into the wiki so you can go deeper on any node. The spine: first understand what the model is bad at, then build the scaffolding that fixes it.
flowchart LR
F[Foundations] --> C[Context]
C --> E[Evals]
E --> V[Verification]
V --> H[Harness]
H --> S[Factory]Module 1: Foundations
Lesson 1: How agents actually fail
Start here because everything else is a response to these failure modes. Agents generate volume, and volume without discipline is slop. Karpathy’s four guidelines are the minimum conduct rules: think before coding, simplicity first, surgical changes, goal-driven. From there, the five debts of agentic engineering name what accumulates when you skip discipline: intent debt, semantic debt, verification debt, architecture debt, authorization risk.
Key sources: Andrej Karpathy, agentic engineering patterns.
Lesson 2: The cost model changed
Code is cheap now. Bad code is the most expensive it has ever been, per Matt Pocock, because agents can ship it faster than you can review it. Drew Breunig’s economics argument cuts the same way: when frontier models are priced like frontier models, a weak harness stops being a rounding error. The old excuse, “the model will paper over it,” died with the free lunch.
Module 2: Context is the game
Lesson 3: Context engineering
Matt Pocock’s framing: the agent’s performance is bounded by what’s in its window. Context engineering means curating AGENTS.md specs, feedback loops, and plan artifacts instead of letting defaults run. Hand-crafted context beats generic context, always.
Lesson 4: Context rot and the smart zone
Two properties of long contexts you can’t negotiate with. Context rot: reasoning degrades as irrelevant tokens accumulate, with the classic “lost in the middle” effect. The smart zone: modern models think sharpest in roughly their first 150k tokens. Design sessions so load-bearing work happens early, or hand off to a fresh context.
Lesson 5: Progressive disclosure and subagents
Don’t load everything up front. Progressive disclosure loads pointers first and full material only on trigger. Subagents isolate high-token exploration in child contexts that return summaries, keeping the root conversation sharp. At fleet scale this becomes multi-agent orchestration, coder to conductor to orchestrator.
Module 3: Evals
Lesson 6: Error analysis before evals
The Hamel Husain and Shreya Shankar discipline: read real failures first, categorize them, then derive rubrics from the taxonomy. Error analysis and evals is the prerequisite; eval suites built without it measure the wrong thing.
Lesson 7: Eval-driven development
Eval-driven development is TDD’s analogue for generative systems, coined in practice at Airbnb and formalized by Husain and Shankar: evals as a continuous loop, not a release gate. Design the generator-evaluator loop with a separate judge, because agents grading their own output confidently grade wrong.
Lesson 8: Design for verifiability
“It’s hard to eval” is a product smell. If you can’t verify an artifact, your users can’t either. Fix the artifact before building the eval harness. This connects straight to automated eval engineering and closed-loop agent improvement, where production failure traces drive candidate patches gated by benchmarks.
Module 4: Verification and code quality
Lesson 9: Red/green TDD with agents
Red/green TDD is the control mechanism for agent code: write the test, watch it fail, write minimal code to pass. Skipping RED risks tautological tests, and with an agent authoring both sides that risk compounds. TDD with agents makes the test suite the truth referee, which is what lets the agent loop independently without a human reading every line.
Lesson 10: Constraint layering and lint gates
Allocate each rule to its cheapest reliable layer. Constraint layering’s maxim: prompt for judgment, script the mechanical, gate the consequential, isolate the dangerous. The Tier 1 implementation is deterministic lint gates, sub-second error-only linting after every edit, converting style policy from probabilistic prompt compliance into mechanical backpressure. Above the mechanical layer, agent containment and blast radius caps what the agent can do, not just what it tends to do.
Module 5: Harnesses and the factory
Lesson 11: Harness engineering
Agent harness engineering is the discipline of designing the runtime around the model: sandboxes, tool contracts, progressive context, verification gates. Real architectures prove the pattern: Codex harness architecture decouples the reasoning loop from execution via a JSON-RPC app server, and DeepSeek Harness runs modular, traceable execution on its Cordis framework. The thesis in both cases: agent = model + harness, and the harness is where reliability lives.
Lesson 12: The agentic software factory
The end state. The agentic software factory is the operating model where agents carry production work from task decomposition to merge, and humans shift to specs, architecture, and exception points. Addy Osmani frames it as owning the outer loop. Quality is measured as releasable patch rate, the joint probability of correctness, regression safety, security, architecture, and scope, with the evidence map in agentic code quality and conformance suites as fitness functions keeping agents honest.
Module 5.5: The human layer
Two lessons the factory can’t skip. First, cognitive debt and walkthroughs: if you merge code you don’t understand, the codebase becomes a black box that paralyzes your next design decision. Linear walkthroughs and interactive explanations are the antidote. Second, hoard and recombine: collect working snippets and proof-of-concept tools, then feed them to agents as concrete reference material. Knowing something is possible is weak; possessing a tested snippet proves it.
How to run the course
Read the lessons in order; each one is short on purpose. When a lesson lands, follow its wiki links and read the primary sources they cite. The Feynman technique applies to the whole thing: after each lesson, explain the pattern to someone in plain English. If you can’t, you found the gap.