Curriculum — Agent-First Engineering¶

From "vibe coding" to systems engineer for agents. Six foundations phases, a two-phase Advanced tier, and a Project Lifecycles module, one competency each, taught one concept at a time with diagrams, worked examples, a hands-on exercise per lesson, and a hard quiz. Agent-agnostic (Claude Code / Codex / Cursor), built on open standards.

Quiz yourself: in Claude Code (or any agent with the skill installed) run /check-understanding <phase> — e.g. /check-understanding context-engineering. The check-understanding skill (in the repo under .claude/skills/) reads the phase's quiz.json and runs a fresh interactive quiz, with difficulty selection.

The progression¶

flowchart LR
    V[vibe coding] --> P1[P1 · Fundamentals]
    P1 --> P2["P2 · Context Engineering ★★★"]
    P2 --> P3["P3 · Verification & TDD ★★★"]
    P3 --> P4[P4 · Session & Memory]
    P4 --> P5[P5 · Spec-Driven Dev]
    P5 --> P6[P6 · Orchestration & Harness]
    P6 --> S[systems engineer for agents]
    S --> P7["P7 · Advanced Patterns<br/>(building blocks)"]
    P7 --> P8["P8 · Production Patterns<br/>(optimize · extend · ship)"]
    P8 --> P9["P9 · Project Lifecycles<br/>(map → automate)"]

#	Phase	You'll be able to…	Scaffolder artifact (lockstep)
1	Fundamentals	Drive explore→plan→code→commit with specific, context-rich prompts; use plan mode.	the `init` interview UX
2	Context Engineering ★★★	Treat the context window as scarce: `/clear`, compaction, fresh sessions, spec handoff.	capture-learnings memory loop
3	Verification & TDD ★★★	Give the agent an external oracle so it closes its own loop.	test-gate / `Stop`-gate hooks
4	Session & Memory	Course-correct early; author and prune minimal `AGENTS.md`/skills; promote rules to hooks.	`AGENTS.md` + `.agents/skills/`
5	Spec-Driven Development	Turn a vague idea into an executable spec; the spec is the source of truth.	Spec Kit hand-off
6	Orchestration & Harness	Small focused agents, adversarial review, worktrees; design the environment, not the edit.	full guardrail + CI + adapters
7	Advanced Patterns (Advanced)	The building blocks: skills, hooks, MCP, security, subagents.	the internals of what the scaffolder emits
8	Production Patterns (Advanced)	Operationalize them: caching (cost), computer use (capability), plugins (distribution).	—
9	Project Lifecycles (Module)	Map the full lifecycle (software · ML/DS · AI apps) end to end — the loop you'll later automate.	—

★★★ = load-bearing. If you internalize only two phases, make them 2 and 3 — context engineering and verification carry the most weight across every researched source.

Capstone (graduation): run the scaffolder on a real project (or adopt an existing one) and annotate each generated artifact with the phase that taught it. The tool stops being magic and becomes automation of a process you understand.

Full table of contents¶

Phase 1 — Fundamentals: the agentic loop ¶

The loop — Explore→Plan→Code→Commit.
Prompt specificity — file, constraint, example, done.
Feeding context — feed it, don't describe it.
Personas & perspective — a role aims the view, not the IQ.
Plan mode first — plan before you build.

Phase 2 — Context Engineering ★★★¶

The context window is a desk — finite working space.
Context rot — more context can make output worse.
The three moves — /clear, /compact, fresh session.
The spec handoff — think in one session, implement in a clean one.
What the scaffolder automates — the capture-learnings memory loop.

Phase 3 — Verification & TDD ★★★¶

"Looks done" isn't done — without an oracle, you are the loop.
The oracle gradient — four strengths of oracle.
TDD with agents — tests-first is an oracle code can't fake.
Oracles for the un-testable — screenshot-diffs for UI.
What the scaffolder automates — the Stop-gate + post-edit hooks.

Phase 4 — Session & Memory Discipline ¶

Course-correct early — interrupt drift instantly.
AGENTS.md done right — short, imperative, command-first.
Skills, rules & commands — when knowledge should surface.
Prose to hooks — if it must happen every time, it's a hook.
What the scaffolder automates — steering + prose-to-hook promotion.

Phase 5 — Spec-Driven Development ¶

Why specs beat prompts — the spec is durable; code is regenerable.
The Spec Kit loop — constitution → specify → plan → tasks → implement.
WHAT vs HOW — the spec is WHAT; the plan is HOW.
Spec as steering wheel — catch ambiguity on paper.
Scaffolder ↔ Spec Kit handoff — the two tools compose.

Phase 6 — Orchestration & Harness Engineering ★★★ (capstone)¶

Small, focused agents — scope kills quality.
Adversarial review — a fresh-context reviewer.
Parallelism & worktrees — isolated fan-out.
Harness engineering — enforce with linters + CI.
Defining team direction — non-negotiables as hooks.
The scaffolder is the capstone — recognize every artifact.

Phase 7 — Advanced Patterns: encode & automate (Advanced tier)¶

Anatomy of a Skill — name+description load always; the rest on demand.
Hooks, deep — deterministic enforcement on lifecycle events; exit 2 blocks.
MCP, deep — one open protocol; servers expose Tools, Resources, Prompts.
Security & injection — enforce safety in the harness, not the prompt.
Anatomy of a Subagent — a focused specialist: own context, own tools, delegated by description.

Phase 8 — Production Patterns: optimize, extend & ship (Advanced tier)¶

Prompt & context caching — cache the stable prefix; reads cost ~0.1×.
Computer use & browser agents — eyes + hands; a browser as a visual oracle.
Plugins & marketplaces — bundle skills+hooks+subagents into one shareable unit.

Phase 9 — Project Lifecycles: the loop you ship into (module)¶

The lifecycle is a loop — "done" spans creation AND operation; release is the midpoint.
The software lifecycle — SDLC → Agile → DevOps/CI-CD → DORA → SRE.
The ML / data-science lifecycle — data-centric build→deploy→monitor→retrain.
The AI application lifecycle — non-determinism + a data loop; evals are the oracle.

What's next? The Advanced tier (Phases 7–8) is now live. See the Roadmap for the backlog of further topics still to come.