A3.2 · The roadmap layer
Small batches
Small releases, incremental design, and continuous feedback — the three Extreme Programming practices that make a release cheap to ship, review, and undo, re-cast for an Author/Operator pair.
A smaller batch lowers risk and feedback latency and raises learning per cycle. Shrink the dial on the right across the Portal's real nine-rung F6 ladder and watch all three move. A Claude agent that ships one well-specified rung at a time is what makes a small batch the cheap default rather than a discipline you must force.
Shrink the batch · risk and latency fall, learning rises
One dial proves the module: as the batch shrinks toward a single rung, risk and feedback latency fall and learning per cycle rises.
The batch argument
A batch is the work shipped between two reviews. Extreme Programming’s small-batch practices all push the batch toward a single increment, because a smaller batch is cheaper on three axes at once. Less is at stake if a release is wrong, so risk falls. A reviewer meets the work sooner, so feedback latency falls. And the same total work passes through more reviews, so learning per cycle rises. The dial above moves all three over the Portal’s nine-rung F6 ladder; this module unpacks the three practices that hold the batch small.
The new argument this module adds: a small batch used to be a discipline a team had to enforce against the pull of “ship it all at once.” With a Claude Author that turns one rung into a spec triad, a slice, and a green harness, a batch of one is cheap to produce — so small batches become the default the workflow runs at, not a cost it pays.
The principle
Keep the batch small — small releases, incremental design, continuous feedback — so each release is cheap to ship, cheap to review, and cheap to undo.
On the Portal
The phoenix.roadmap.md is nine rungs, each a PR-sized slice shipped and demoed
before the next is planned — the agent makes each batch of one cheap to produce.
Small batches are an XP idea; an agent that ships one well-specified rung at a time makes them the cheap default rather than a discipline you must force.
The three practices
Three dives carry the module — one per XP practice, in order. Each is re-cast for an Author/Operator pair and grounded on the real F6 ladder: small releases (the batch of one), incremental design (the design grown rung by rung), and continuous feedback (the loop closed between rungs).
Small releases
Why a smaller batch lowers risk and feedback latency and raises learning per cycle — release small, release often.
Incremental design
The design grows one rung at a time behind a stable facade — add only the structure the current slice needs.
Continuous feedback
Feedback after every rung, not at the end — the loop closes between rungs and feedback edits the spec, never the shipped page.
The F6 cadence the dives build on
All three dives stand on one real artifact: the Portal’s phoenix.roadmap.md.
It climbs nine rungs f6.1…f6.9 across three milestones — ship the
catalog, make it live, ship to users — one shippable capability per rung. Each rung is a PR-sized
increment: a spec triad, the slice, a green harness, a demo, and a feedback note. The roadmap states the
per-rung loop verbatim: sharpen → build → ship → demo → review → feedback
→ adapt. That cadence is the three XP practices running together.
Portal facade; PubSub, auth, and the dashboard are deferred to the rung that needs them (A3.2.2).The first dive opens the batch argument in full: A3.2.1 · Small releases.
References
The sources behind small batches and the loop, and where this module connects in the course and to the real F6 chapter it is grounded on.
Sources
- Beck, K. — Extreme Programming Explained — small releases, incremental design, and continuous feedback as core practices.
- Humble, J. & Farley, D. — Continuous Delivery — small batches and keeping the system releasable at every increment.
- Hunt, A. & Thomas, D. — The Pragmatic Programmer — incremental, feedback-driven delivery over big-bang plans.
Related in this course
- A3 · The roadmap layer — the chapter this module sits in.
- A1.01 · The two failure modes — big-bang versus the thin slice a small batch ships.
- A1.03 · The Author/Operator loop — the cadence that runs one rung end to end.
- A2.07 · Workshop — the run that produced the nine-rung F6 ladder.
- A3 · The road ahead — the chapter's module overview.
- Companion · Phoenix (F6) — the real chapter built one rung at a time.
- Companion · Functional Programming in Elixir — the Portal's Elixir and OTP foundations.