16 tasks, 47 subagents, zero humans: the overnight build
A 16-task plan, 47 subagents, and two models from two vendors adversarially reviewing each other overnight — what the structure caught while I slept.
At 1:03am on July 18 I started a Claude Code session inside herdr, pointed it at a 16-task implementation plan, and went to bed. At 9:36am the plugin was live on my machine: a daemon sweeping my real fleet under systemd, a working board TUI, 118 passing tests, 58 commits, and a review log showing roughly 70 findings caught and resolved while I slept. Every one of the 16 tasks shipped.
I want to write down how, because the interesting part isn’t that agents can write code overnight. Everyone knows that by now. The interesting part is the structure that let them do it without me, and what that structure caught.
The mission doc
You don’t hand an agent eight unsupervised hours with vibes. The kickoff was a one-page mission doc that Claude and I wrote together before I went to bed, and in hindsight every paragraph of it earned its place.
It named the source of truth: a 16-task plan, reviewed and approved in advance, copied into the repo as its first commit. It pre-granted the plan’s checkpoints, the specific spots where the plan said “stop and ask Blake,” each with its own conditions, because I wouldn’t be there to ask. It set standing rails that no grant could override: no deletes, ever, stage removals into a folder instead; never force-push; never touch main of any repo except the new one; no secrets outside the password manager; subscription-lane model calls only. And it set a blocker policy: three genuinely different attempts on a stuck task, then write the full state to a blockers file, commit it, and move on to the next task that doesn’t depend on it. Never wait for a human who isn’t coming.
A subagent saying “done” counts for nothing.
The doc also encoded distrust, which is the part I’d underline. Every task’s completion had to be verified by the orchestrator against the plan’s acceptance criteria. A subagent saying “done” counts for nothing.
The shape of the night
The orchestrator ran subagent-driven development: a fresh subagent per task, so no task inherits the previous task’s context rot. Over the night it dispatched 47 of them. The rhythm for each task was implement, review, fix, re-review, and the dispatch log reads like a wave pattern: “Implement Task 5: scrape floor.” “Review Task 5.” “Fix Task 5 findings.” “Re-review Task 5 fix.”
Model routing followed a rule from my global setup: cheaper models for mechanical work, the expensive one only where judgment matters. Most implementation dispatches ran on Sonnet. The reviews of the trickiest tasks, the event reducer and the daemon, ran on Opus. The whole night cost about 1.37 million output tokens on a subscription plan. I’ve had cheaper nights of sleep, but not many more productive ones.
Then there’s my favorite structural detail: the second reviewer wasn’t Claude at all. In a sibling herdr pane, a Codex CLI session sat as an independent review gate. After each task passed its own tests, the orchestrator messaged the Codex pane with the commit range, and Codex reviewed the diff cold: re-running the test suite itself, probing edge cases, checking the work against the plan text. Two different models from two different vendors, adversarially reviewing the same diff, coordinated through a terminal multiplexer. The mission doc had specced a simpler review lane; we upgraded it to the live sibling-pane arrangement right before I went to bed, and it turned out to be the best decision of the night.
What the gates actually caught
The review log is the artifact I’d show a skeptic — though for now it lives in a private archive with the raw transcripts, so what follows is my summary of it, and you’re right to discount what you can’t inspect. Publishing redacted excerpts is an open decision on my list. Roughly 70 findings across the night, every one either fixed with a commit reference or dismissed with a written reason. A sample:
The append-only feed had a rotation bug where two rotations in the same second would silently destroy an archive. That’s the exact invariant the whole design rests on, replayability, and it was in code copied verbatim from the approved plan. Codex reproduced the history loss and it was fixed with microsecond-precision naming and a regression test.
The herdr CLI wrapper assumed pane reads returned JSON. On the live system they return plain text. The entire scrape path, the floor the product stands on, was dead on arrival, and no planned test covered it. Caught because the reviewer ran against the real fleet instead of trusting the mocks.
The board’s headline feature, pressing enter to jump to an item’s source pane, was unreachable: a widget’s built-in binding shadowed the app-level one. Severity Critical, found by an automated UI test the reviewer wrote, fixed, then verified with a real keypress moving real focus.
A worker subagent deserves its own mention. Its instructions said to implement the plan verbatim and never deviate silently. Partway through, the plan’s own regex fixture failed: the plan had a subtle owner-classification bug in it. The worker stopped and flagged BLOCKED rather than quietly patching around it, the coordinator confirmed the plan itself was wrong, authorized a one-line deviation, and logged it. That’s the discipline I most doubted an agent chain could hold overnight, and it held.
There’s an honest lesson in the log too: three findings in the daemon’s later review rounds were introduced by earlier review fixes. Reviews generate code, code carries risk. The cross-reviewer setup caught each one within a round, but “the fix broke something adjacent” doesn’t stop being true just because everyone involved is a model.
What didn’t work
The night hit real walls, and the blocker policy handled them the way it was written. The Claude Code Stop hook, one of the two hooks that let sessions self-report, never fired on this machine. Three distinct diagnostic approaches, all documented, all ruled out the script itself; the trail went into a blockers file with a note that impact is low because the scrape floor exists precisely to cover sessions that don’t self-report. The phone-push lane assumed a CLI verb that turned out not to exist, so the daemon shipped with a desktop-notification interim and the phone decision was left in my court. And the daemon spent part of the night sweeping my main fleet instead of the build sandbox, which sounds like a bug until you realize the env-less binary binds the default herdr instance. The main fleet is the actual product target; the behavior was kept and documented.
I woke up to all of this already triaged: Linear tickets moved with commit SHAs in the comments, a project status update posted, and a morning-reads list of exactly the decisions that needed a human.
The epilogue the roadmap wrote itself
My palm brushed my new keyboard and acked nine items off the board. Because every ack is just an appended event and nothing ever rewrites history, recovery was clean: append one snooze event per victim with a wake time already in the past, and the reducer flipped each item back to exactly its prior state. My favorite bug report I’ve ever filed.
The palm also exposed a genuine gap, no undo and no archive view, which became the project’s first post-launch ticket within ten minutes.
That loop, from accident to recovery to roadmap item, ran on the same append-only design the agents had spent the night defending against each other. I went to bed with a spec and woke up with a product that could already survive my keyboard. We’re on the dogfood clock now; when the seven days are up, muster goes public.