Agentic Engineering for Software Teams

The route

Use the two opening maps to find your gaps, then take Context Engineering before the later Agentic Engineering stages; the prompting stage can run in parallel. Each stage names the test for skipping it — a route you skim in twenty minutes is worth more than one you abandon in the middle.

1. Stage 01

   Decide whether your team needs this

   2 lessons · 24 min

   Both modules open with a self-assessment whose stated job is to route you. Read the two maps back to back and send people to the gaps they actually have, instead of marching everyone through the whole route.

   Skip this stage if you have already run both self-assessments and know which items your team cannot do confidently today.

   • Beyond the Prompt 12 min The team map: what changes when an agent stops answering and starts operating.
   • How the Builders Prompt 12 min The craft map: seven techniques set against what Module 10 already taught you.
2. Stage 02

   The lesson the module tells you to read first

   1 lesson · 20 min

   This is the one place the route departs from the published order, and the lesson makes the argument itself: "Start with Lesson 2. Context Engineering underpins everything else. Even if you only read one lesson in this module, read that one." Later lessons on subagents, specs and runbooks all assume it, so it gets its own stage rather than a slot.

   Skip this stage if you can already keep an agent sharp across a week-long project without context rot — the one skip to be most honest about, because every later Agentic Engineering stage builds on it.

   • Context Engineering 20 min Context rot, compaction, retrieval, note-taking, isolation — and what makes a memory file actually constrain behaviour.
3. Stage 03

   Prompting craft

   7 lessons · 103 min

   Seven techniques that improve any single agent turn. Kept in published order because they chain — the tags from Structure are the mechanism Grounding builds on, and the last lesson is a capstone that combines the six before it. Nothing here depends on the tooling stages, so a team splitting the work can run this in parallel.

   Skip this stage if your team already primes with a role, shows examples, makes the model reason before answering, separates instructions from data, grounds answers in quoted sources, chains steps, and tests prompts against cases.

   • Give the Model a Role 12 min Prime behaviour before the task: a specific expert, what they care about, how they answer.
   • Show, Don't Tell 14 min Examples beat description — consistency, variety, and the refusal case.
   • Let the Model Think 14 min Reasoning before the answer, parked in a scratchpad — a technique, not a setting.
   • Structure and Format 15 min Tag the parts so instructions and data cannot blur, and name the output shape.
   • Ground the Answer 16 min Quote first, answer second, and permit "not found" — the lesson calls this the biggest single win.
   • Chain Your Prompts 14 min Split an overloaded prompt into steps that each do one job.
   • Test and Keep What Works 18 min Success criteria and varied cases, one change at a time; combines the six above.
4. Stage 04

   Extend and orchestrate the agent

   3 lessons · 62 min

   Where "agents in the pipeline" becomes literal: reaching your systems through an external tool server, encoding team conventions once so they are enforced rather than requested, and running more than one agent on purpose.

   Skip this stage if your team can already connect and vet a tool server, author a cross-tool skill and a hook that enforces a guardrail, and decompose work across parallel agents — and anyone reaching for worktrees is comfortable with branches and merges, which the lesson names as its own prerequisite.

   • MCP: Extending Your Agent 20 min Connect an external tool server over MCP (the Model Context Protocol) — and vet it before you trust it.
   • Skills, Hooks & Custom Commands 20 min Author a skill once for any tool; hooks enforce what a memory file only asks.
   • Subagents & Orchestration 22 min Fan-out, pipeline, supervisor, debate — plus worktrees, which assume you are comfortable with branches.
5. Stage 05

   Run it as infrastructure

   4 lessons · 81 min

   The stage a tech lead is actually approving: unattended runs and the guardrails each one needs, a spec the team reviews and the agent executes, independent review before a risky change ships, and a runbook a cold agent can finish.

   Skip this stage if your team can already run agents safely from a script or CI, decide when work needs a committed spec, send risky changes through independent review while skipping it for routine ones, and write a runbook a cold agent can finish.

   • Headless Agents & CI 20 min Agents as a unix tool — script, cron, CI, cloud — and the guardrails each step needs.
   • Spec-Driven Development 18 min A spec the team reviews and the agent executes; its own test is whether the question survives 48 hours.
   • The Council Pattern 18 min Independent multi-model review before a risky change ships — and the list of times not to convene one.
   • Runbooks: Docs Agents Execute 25 min Capstone: a five-phase runbook a cold agent finishes with no questions, graded by execution.