Where we are

A recap is a locator, not new material. The course is one argument carried across eight parts. Three are built and stand under this one.

A0 — Foundations framed the method in three questions — why it works, what we build, who does the work — and 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). The Author/Operator loop is the cadence that runs one rung end to end.

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 its cadence, and A1.04 — Two layers drew the line A3 inherits: the roadmap is how we deliver, the spec is what we build and prove, 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.

Two facts decide everything A3 teaches, and a recap exists to make them concrete. Where the roadmap sits: it is the layer over the spec layer, and it points down at specs. It carries the order, the batch size, and the milestone — never a behaviour. Re-ordering the roadmap moves the delivery order; it cannot edit a spec. The spec is the single source of truth, and only feedback edits it (A1.04).

Who acts: the Operator sequences and prioritises the roadmap, and accepts each rung against the demo; the Author builds the rung against its spec. Re-ordering, defining behaviour through feedback, and accepting are Operator moves. Production is the Author's. The line between the two roles is the same one the loop in A1.03 drew.

The figure renders that as a stack. Choose a role on the left, then an action, and the readout reports which layer the action touches and who owns it — proving that re-ordering touches the roadmap and never the spec, and that the Operator owns sequencing.

Take the Portal's F6 web backlog from the A2 workshop — nine rungs of user stories, already ordered into a value ladder. A2 answered what is worth building. A3 turns that ladder into a roadmap.md that points at each rung's spec, groups the rungs into shippable milestones, and is re-ordered by feedback between rungs. The roadmap.md defines no behaviour; every behaviour lives in a spec the roadmap line points at. The Operator sequences the ladder; the Author builds each rung against its spec.

# roadmap.md — the coarse, re-orderable plan of how we deliver (the A2 ladder, sequenced).
# Every line POINTS AT a spec; no line defines behaviour. The Operator owns the order.

## Milestone 1 — a learner can find and open a lesson
1. browse the catalogue   → spec: catalogue.md
2. enrol in a course      → spec: enrol.md
3. open a lesson          → spec: lesson.md

# Behaviour lives only in the linked spec. A typed id threads through every rung:
id = Portal.ID.generate(:user)        # the Author builds each rung to its spec
assert Portal.ID.decode(id).type == :user   # proven, not asserted

# Feedback re-orders the roadmap between rungs — it never edits a spec from here.

The course is one argument across eight parts. Three are built: A0 framed the method and named the Operator and the Author, A1 made the case for thin, provable slices and the loop that runs them, and A2 produced a backlog — a value ladder of user stories. A3 plans the delivery of that backlog. Two facts carry forward: where the roadmap sits (over the spec layer, pointing down, never defining behaviour) and who acts (the Operator sequences and accepts; the Author builds). With those fixed, the next dive defines the layer itself.

Where the discipline this layer plans is defined, and where the layers and roles it locates live in the course.