> Marcus Hobbs

The funnel: parallel readers mapped the prototype against shipped specs and surfaced that it secretly bundled three initiatives — the highest-leverage human decision of the project was a scope gate that deleted roughly two epics of accidental scope before any code existed. Then 122 requirement candidates were reconciled against the shipped catalogs (19 conflicts, all resolved; 6 operator product rulings), and 114 requirements were authored with permanent, immutable IDs — before a single line of implementation.

The graph: the spec was minted into 45 thin, vertical, end-to-end slices wired by blocked-by edges. Readiness became computable — the loop derived the ready set directly from the tracker, so no one hand-ordered the work. Laid out by build depth, the graph's columns are waves: every slice in a column became buildable the moment the prior wave merged. Tall columns are exactly where two lanes ran in parallel; the critical path set the floor.

The loop: each lane ran the same nine-step spine — pre-flight, sync real data, implement with a file-domain-isolated strike team, verify against the running app, multi-lens review, fix every finding, iterate until clean, capture learnings, honor the autonomy dial. Verification was tiered to risk, not convenience: the drain lead re-ran every gate personally, read every diff, drove the live app via browser automation, and queried the database directly for ground truth on write paths. 111/111 end-to-end scenarios green; the defects were caught upstream in each lane's QA loop, so the final gate acted as confirmation.

The human budget: eight decisions steered all 45 tickets — a scope gate, a reversal blessing, six product rulings, the ticket-mint authorization, the drain gate, pacing, and mid-build product questions recorded for a PM instead of decided by an agent. Every one of the ~92 PRs was read and approved by a human. Autonomy over execution — never over judgment.

Two pipelines share one engine. Small work enters through a triage front door and runs one lane to a PR; big features enter through the spec-decomposition funnel and end in an epic drain. Every lane — solo or drained — runs the same spine: real-data sync, a file-domain-isolated strike team with a QA loop, live verification against the running app, multi-lens read-only review, fix-every-finding iteration, and learnings capture before ship.

Plans argue for their lives before execution: the debate engine runs a 3-lens reviewer panel (correctness, coverage, consistency) that traces the requirement through the codebase before reading the plan, then an author agent validates every blocker against real code — as deterministic workflow code with severity gates, round caps, token reserves, and a formal dispute-escalation path that hands genuine disagreements to the human, never auto-resolves them.

Everything runs under budgets and stop conditions: spawn caps, a 3-strike rule keyed on root-cause tags (not failure counts), broken-baseline hard stops, and an operator-owned-decision rule — a genuine product call always stops the loop and hands back. Subagents never return prose; every fan-out is schema-validated, so orchestration consumes typed data.

Prompt engineering is converging across teams, but nobody's harvesting what travels. I surveyed a brownfield team's suite — roughly 6,800 lines, 21 slash commands, 5 subagent templates — the way you'd read another engineer's library: what's generalizable versus what's load-bearing on their specific context.

Five patterns travelled: risk-driven mode selection, file-domain isolation between subagents, task-log files as durable phase contracts, active-fixer review agents, and frontmatter-registered subagents. I adopted all five into a different team's greenfield suite and wrote a teammate-facing report so other AI engineers could pilot the same patterns without re-doing the archaeology.