A3 · chapter overview
The roadmap layer
Decomposition gave you a backlog. A roadmap plans its delivery — thin-but-robust increments, grouped into milestones, sequenced and re-sequenced by the inspect-and-adapt loop. The slice stays the unit; the question becomes the order and size it ships in.
A2 produced a value ladder of small, testable stories. A backlog says what is worth building; a roadmap says in what order, at what size, to what milestone it ships. This chapter is the layer between the two: how to plan delivery without touching the spec, and how feedback re-orders the plan between rungs — all practised on the Portal.
Where we are
The course is one argument carried across eight parts. The first three are built: A0 framed the method, A1 made the case for thin, provable slices, and A2 turned a vision into a backlog of them. A3 is where the backlog becomes a delivery plan. The remaining parts — the spec layer, the agent brief, reliability, and the Portal exemplar — build on top of it.
The arc below walks the eight parts. Select one and the readout reports its title, what it delivers, and whether it is built — the same orientation this landing exists to give. The default selection is A3, the part you are reading.
The course arc — eight parts, A0 to A7
A0–A2 settled why, what, and which slices; A3 settles the order and size they ship in. The roadmap is the layer between a backlog and a built system.
The journey so far
A0 — Foundations framed the method in three questions: why an agile agent workflow works, what we are building, and who does the work. It named the two roles the rest of the course runs on — the human Operator (judgement, decomposition, acceptance) and the Claude Author (fast, well-specified implementation).
A1 — Why an Agile Agent Workflow made the case. Neither no-plan vibe-coding nor an all-plan big-bang ships reliable software; the unit that does is a thin, provable slice. The Author/Operator loop is the cadence that runs one rung end to end, and A1.04 — Two layers drew the line this chapter inherits: the roadmap is how we deliver, the spec is what we build and prove, and they are kept apart on purpose.
A2 — Decomposition produced the work the loop runs on: a backlog. It taught value not tasks, the Connextra form, INVEST, Given/When/Then acceptance, splitting stories that are too big, and ordering the result into a value ladder. The A2.07 workshop ran the whole sequence on the Portal's real web surface to yield its nine-rung F6 ladder — the backlog A3 now plans to deliver.
The principle
A backlog is a set of slices ordered by dependency and value. It answers what is worth building, but not the sequence, the batch size, or the milestone each rung serves.
On the Portal
A roadmap.md sequences those slices into thin-but-robust increments and groups
them into shippable milestones — pointing at each spec, defining no behaviour, re-ordered by
feedback between rungs.
Decomposition answers what to build; the roadmap answers in what order, at what size, and to what end — and nothing in it edits the spec.
The roadmap layer, in five questions
The roadmap layer is a single artifact with a single job: plan delivery without redefining the work. Five questions fix what it is, why it exists, who owns it, when it changes, and how it operates — the deep overview the three orientation dives then unpack.
roadmap.md — the coarse, re-orderable plan of how we deliver. An
ordered list of thin-but-robust increments grouped into milestones, each pointing at a spec and defining no
behaviour of its own.Each question opens into one of the three orientation dives below: where-we-are takes the recap and the Where and Who; the-roadmap-layer takes the What and Why; the-road-ahead takes the When and How and previews the eight modules that follow.
Orientation dives
Three short dives orient you before the chapter's eight teaching modules. Read them in order: where the course stands, what the roadmap layer is and why it exists, and a guided tour of the road ahead.
Where we are
The journey A0→A2 recapped: the method, the case for thin slices, and the backlog this chapter delivers.
The roadmap layer
Why delivery deserves its own layer, and what a roadmap.md is — the artifact that points at specs but defines none.
The road ahead
A deep overview of the eight A3 modules ahead: Agile and XP, the roadmap.md, robustness, milestones, and tracer bullets.
The chapter modules: A3.1–A3.9
Eight teaching modules carry the roadmap layer end to end — from the agile values behind it to a worked roadmap of the Portal — followed by a reference appendix, A3.9 (a glossary, the sources, and where the framework implements each idea). They build in order: the philosophy, the artifact, what makes an increment robust, how rungs group into milestones, sequencing a whole program, the first end-to-end tracer, the workshop, and the appendix.
Agile, distilled
The values and the loop behind every later technique, stripped to the essentials that matter for one thin slice.
Extreme Programming for small batches
The XP practices that survive — and sharpen — when the batch is a single, provable increment.
Anatomy of a roadmap.md
The artifact itself: rungs, milestones, and the line that points at a spec without restating it.
Thin but robust
A slice can be small and still production-grade; what “robust” adds to “thin” on every rung.
Milestones and iterations
Grouping rungs into shippable milestones, and the iteration cadence that walks them under feedback.
The program roadmap
Sequencing many chapters of work: dependency and value across a whole program, not one feature.
Tracer bullets and walking skeletons
The first end-to-end increment that proves the architecture before the rest of the backlog lands.
Workshop — roadmapping Portal
The full sequence on the Portal: one backlog turned into an ordered, milestone-grouped delivery plan.
Glossary, references & the framework crosswalk
A UX-friendly expandable list: every key term with its abstract, its source, and where the Portal implements it.
Each module is a hub with its own deep-dive subpages — the same shape A1 and A2 take. Start with the orientation dive Where we are, or open a built module above.
References
The sources this chapter draws on for delivery, small batches, and the first end-to-end increment, and where the layers it sits between are defined in the course.
Sources
- Humble, J. & Farley, D. — Continuous Delivery — keeping the system releasable at every increment; delivery as the discipline this layer plans.
- Beck, K. — Extreme Programming Explained — small batches, iterations, and the inspect-and-adapt loop.
- Hunt, A. & Thomas, D. — The Pragmatic Programmer — tracer bullets and walking skeletons: the first thin increment that runs end to end.
Related in this course
- A2 · Decomposition — the backlog this chapter sequences.
- A1.04 · Two layers: roadmap and specs — the roadmap/spec separation A3 expands.
- A0.2.2 · The four artifacts — the per-rung artifacts a roadmap line points at.
- A3 · Where we are — the recap dive.
- A3 · The roadmap layer — the what-and-why dive.
- A3 · The road ahead — the modules-ahead dive.
- Companion · Phoenix (F6) — the real chapter built from a
phoenix.roadmap.md. - Companion · Functional Programming in Elixir — the Portal’s Elixir and OTP foundations.