What Got Built While I Slept

Of everything in my workflow, this is the part that sounds most like science fiction and is most mundane in practice: I queue up software tasks in the evening, autonomous Claude Code sessions work through the night, and I review the results over coffee. Features built, bugs fixed, tests written, while I slept. This article explains how it actually works, including the unglamorous parts, and it doubles as the companion piece to the vlog series where I review a real morning's output on camera.

The setup, conceptually

Strip away the mystique and it is a delegation system with three parts:

1. Well specified tasks. Each piece of work is written up like a brief to a contractor: what to build, where it lives, what done looks like, what not to touch. This is the skill, and it is a writing skill, not a coding one
2. An agent with tools and a loop. Claude Code, per the agents article, opens the project, plans, edits files, runs the tests, reads the failures, and fixes them, iterating until the brief is met or it hits something needing a human
3. Guardrails and receipts. Everything happens in version control on branches, so nothing touches production without review, tests must pass, and each task ends with a summary and screenshots of the result waiting for me

The morning review is a pull request queue: here is what was asked, here is what was done, here is the evidence it works. Approve, request changes, or reject, exactly like reviewing a team's work, because that is what it is.

What a good night produces

The tasks that succeed overnight share a shape: bounded, verifiable, and well described. The unglamorous backlog that every software project accumulates, the small features, the polish, the test coverage, the refactors nobody gets to, this layer melts. A realistic good morning is several completed, tested, documented pieces of work that would have consumed my focused hours, done while I was unconscious.

Where it goes wrong, honestly

Bad briefs produce confident nonsense: the agent builds exactly what I wrote instead of what I meant, and does it thoroughly. Ambiguity in equals rework out, every time, which is why the brief writing is where my actual effort lives. Some tasks stall on judgement calls and correctly wait for me rather than guessing, that is the guardrails working. And review is non negotiable, not because the work is usually wrong, but because the one unreviewed merge you regret costs more than a hundred reviews. Anyone selling you autonomous coding without the review step is selling you a future incident.

Why this matters beyond software

Here is the transferable insight, and it is the reason this article sits in a series for general readers: the constraint on delegation was never willingness, it was specification. The overnight system works exactly as well as my briefs are clear, and that discipline, deciding precisely what done looks like before handing work over, is improving how I delegate to humans too. AI is a mirror for your management habits. Mine needed the polish.

The next article goes one step weirder: I don't even open the laptop to start these jobs. I send a text.