The road ahead

The first two dives placed the roadmap layer and defined it. Two questions remain, and the chapter ahead answers both. When does the roadmap act? It is written after decomposition, read at the start of each rung to pick the next slice, and re-ordered by feedback between rungs. It changes often and coarsely. The spec changes rarely, and only through feedback. One workflow, two cadences: the roadmap re-orders; the spec is edited.

How is the roadmap walked? A rung is a thin-but-robust increment — a narrow vertical slice built to production quality, not a flimsy stub. Rungs group into shippable milestones. An inspect-and-adapt loop walks them: ship a rung, demo it, take feedback, re-order the roadmap, build the next. The loop re-orders the roadmap; it does not edit a spec and it does not decide — the Operator reads what the demo and the feedback show and re-orders accordingly.

Eight modules carry the roadmap layer from the values behind it to a worked Portal roadmap. They are ordered, not a menu — each is small, complete, and stands on the ones before it. The hero map renders them as a spine; the cards below carry the same eight in reading order, each tagged with the concern it serves. They are described here, not linked: none are built yet, and a link would dangle. As the chapter is authored, each becomes a hub with its own deep-dive subpages — the shape A1 and A2 already take.

The how the chapter teaches is a single loop walked over and over: ship a rung, demo it, take feedback, re-order the roadmap, build the next. The ring below is that loop. Step through its five stages and the readout reports what each stage does — and which layer it touches. Two facts hold across every step. The loop re-orders the roadmap; it never edits a spec, which only feedback edits, on a slower cadence. And the loop does not decide: the Operator reads the demo and the feedback and re-orders; the Author builds the next rung against its spec.

The strip under the ring shows a fixed set of seven rungs grouped into three milestones — the move A3.5 teaches. Grouping is ordered bundling, not new behaviour: the rungs keep their order and their specs; a milestone only marks where a shippable unit ends.

Take the Portal's F6 web backlog from the A2 workshop — nine rungs of user stories, ordered into a value ladder. The eight modules ahead turn that ladder into a worked plan. A3.3 gives the roadmap.md its shape: a deliverable, a start/end handoff, the architecture decision — one facade, parallel surfaces over it — the milestones, the per-iteration table, and the open decisions. A3.4 holds every rung to thin-but-robust. A3.5 groups the rungs into milestones and walks them with the Ships/Demo/Harness/Feedback table. A3.7 picks the first rung — a tracer that renders one page end to end over the facade — to de-risk integration before the rest. A3.8 writes the whole thing, and Part VII executes it.

# A3.3 — the chapter roadmap.md the eight modules build toward (a delivery plan, not behaviour).
# Deliverable: the Portal F6 web surface · Architecture: one facade, parallel surfaces over it.
#   M1  r1  tracer: render one page end to end over the facade   → points at spec f6.tracer
#   M1  r2  the catalog list                                     → points at spec f6.catalog
#   M2  r3  the item page          M2  r4  add-to-cart   ...      → each points at a spec

# The branded id rung is one such spec the roadmap points at — defined and proven elsewhere.
id = Portal.ID.generate(:session)       # => "SES0NbAb1xcFCy" (built to its spec)
assert Portal.ID.decode(id).type == :session  # the roadmap line points here; it defines nothing

# Feedback from a demo re-orders the roadmap — it never edits a spec.

The roadmap points at each rung's spec and defines no behaviour. The Operator sequences and re-orders; the Author builds each rung against the spec the line points at. That separation is the line A1.04 drew, carried into the delivery plan the chapter ahead teaches you to write.

The roadmap is written after decomposition, read before each rung, and re-ordered by feedback between rungs — a coarser, faster cadence than the spec, which only feedback edits. It is walked by thin-but-robust increments grouped into milestones and run through the inspect-and-adapt loop. Eight modules teach that, in order: the agile values, XP for small batches, the anatomy of a roadmap.md, thin but robust, milestones and iterations, the program roadmap, tracer bullets, and the Portal workshop. This closes the three orientation dives; the chapter's first teaching module opens next.

Sources for small batches, the inspect-and-adapt loop, and the first end-to-end increment, and where the layers this chapter sits between are defined in the course.