---
title: "The Agentic Engineering Curriculum"
date: "2026-08-30"
description: "A structured course on AI engineering and agentic patterns, distilled from the wiki: foundations, context, evals, verification, harnesses, and the software factory."
---
# 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](/wiki/llm-wiki-pattern) 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.

```mermaid
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](/wiki/karpathy-four-guidelines) are the minimum conduct rules: think before coding, simplicity first, surgical changes, goal-driven. From there, the [five debts of agentic engineering](/wiki/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](/wiki/andrej-karpathy), [agentic engineering patterns](/wiki/agentic-engineering-patterns).

### Lesson 2: The cost model changed

Code is cheap now. [Bad code is the most expensive it has ever been](/wiki/tdd-with-agents), per [Matt Pocock](/wiki/matt-pocock), because agents can ship it faster than you can review it. [Drew Breunig's](/wiki/drew-breunig) 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](/wiki/matt-pocock) framing: the agent's performance is bounded by what's in its window. [Context engineering](/wiki/context-engineering) means curating [AGENTS.md specs](/wiki/agents-md-spec), 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](/wiki/context-rot): reasoning degrades as irrelevant tokens accumulate, with the classic "lost in the middle" effect. The [smart zone](/wiki/smart-zone): modern models think sharpest in roughly their first 150k tokens. Design sessions so load-bearing work happens early, or [hand off](/wiki/handoff-artifacts) to a fresh context.

### Lesson 5: Progressive disclosure and subagents

Don't load everything up front. [Progressive disclosure](/wiki/progressive-disclosure) loads pointers first and full material only on trigger. [Subagents](/wiki/subagents-and-context-management) isolate high-token exploration in child contexts that return summaries, keeping the root conversation sharp. At fleet scale this becomes [multi-agent orchestration](/wiki/multi-agent-orchestration), coder to conductor to orchestrator.

## Module 3: Evals

### Lesson 6: Error analysis before evals

The [Hamel Husain](/wiki/hamel-husain) and [Shreya Shankar](/wiki/shreya-shankar) discipline: read real failures first, categorize them, then derive rubrics from the taxonomy. [Error analysis and evals](/wiki/error-analysis-and-evals) is the prerequisite; eval suites built without it measure the wrong thing.

### Lesson 7: Eval-driven development

[Eval-driven development](/wiki/eval-driven-development) is TDD's analogue for generative systems, coined in practice at [Airbnb](/wiki/airbnb) and formalized by Husain and Shankar: evals as a continuous loop, not a release gate. Design the [generator-evaluator loop](/wiki/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](/wiki/designing-for-verifiability). 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](/wiki/automated-eval-engineering) and [closed-loop agent improvement](/wiki/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](/wiki/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](/wiki/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](/wiki/constraint-layering)'s maxim: prompt for judgment, script the mechanical, gate the consequential, isolate the dangerous. The Tier 1 implementation is [deterministic lint gates](/wiki/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](/wiki/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](/wiki/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](/wiki/codex-harness-architecture) decouples the reasoning loop from execution via a JSON-RPC app server, and [DeepSeek Harness](/wiki/deepseek-harness) runs modular, traceable execution on its [Cordis framework](/wiki/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](/wiki/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](/wiki/addy-osmani) frames it as owning the outer loop. Quality is measured as [releasable patch rate](/wiki/releasable-patch-rate), the joint probability of correctness, regression safety, security, architecture, and scope, with the evidence map in [agentic code quality](/wiki/agentic-code-quality) and [conformance suites as fitness functions](/wiki/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](/wiki/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](/wiki/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](/wiki/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.