Fleet Series 02 — Waves & Leaves: the Coding Pipeline

Working notes for a planned episode — an outline, not an article. Details will shift when it gets scripted. Series index: Building the Fleet.

Deep dive on the coding pipeline: an architect that plans and pushes back, and an orchestrator that builds in waves of small, verifiable leaves.

The hook

"Break the work into small tasks" is advice for humans that turns out to be load-bearing for machines. The pipeline only works because tasks are shaped for workers: small, testable, dependency-ordered leaves. Planning is a separate role from building — and the planner is allowed to tell you your goal is wrong.

What the viewer walks away with

• Two roles, not one agent: architect (plan) and orchestrator (execute) — same repo, different jobs
• The architect's stages: inventory the repo → framing proposal (may push back on the goal) → human approval → decompose into a task tree → emit idempotently
• Task tree anatomy: epic → features → leaves; a leaf is worker-shaped (bounded files, tests required, dependencies explicit)
• Waves: run everything currently unblocked in parallel, verify the wave, reconcile, replan if needed, repeat until the tree is done
• Convergence matters: stable task identifiers, so re-runs dedupe instead of duplicating

Beats

• Open with a bad decomposition failing (one giant vague task) vs. a worker-shaped tree succeeding
• The approval stop: why a human signs off on the framing before any code gets written
• Watch one wave: N leaves fan out, suite gate + review run, reconcile barrier lands them serially (Explainer plates 3 and 4 animate exactly this)
• The replan loop: a failed leaf doesn't kill the epic, it re-enters planning with journal context
• War story: a comma in a task title silently corrupting the dependency graph — tiny data-format details break dependency graphs

Demo ideas

• Run the architect live on a real small epic, show the framing proposal pushing back
• Run the orchestrator on a 5–6 leaf tree, narrating wave boundaries as they happen

Source material

• Lightning Talk — The Loop Is the Easy Part — two of its slides are this episode compressed
• The pipeline's own construction epic (35 of 35 tasks done, completed July 2026, largely built by earlier versions of itself) — the dogfood receipts
• The first fully pipeline-executed feature epic — including the epic gate catching a real no-op bug before it shipped

Open questions

• Does the wave journal (attempt counts, what-landed) get covered here or in episode 06 (provenance)? Probably both, from different angles

Added open question — does the wave loop detect thrash?

The loop-engineering framing names three required stopping conditions: a success condition, a limit, and a no-progress check — and names the failure mode when the third is missing the "Ralph loop": success condition + attempt cap, but no stuck-check, so the budget burns down repeating the same mistake N times instead of stopping after 2.

• We clearly have the first two (gates; attempt counts in the wave journal). Do we detect "same failure signature on consecutive attempts" and escalate to replan or a human instead of retrying? (Since these notes were first written: yes — that guard got built.)
• Beat idea: a stuck leaf tripping a no-progress detector is a better demo than a succeeding one.