we ship code every night. not as a demo. as the actual development process for the system you’re reading about right now.
some of it is good. some of it gets reverted in the morning. here’s what we’ve learned about making the ratio work.
what has to be true
written direction. not a backlog. not tickets. a short document that says what matters this week and what’s off limits. agents boot cold every session. if your priorities require context you haven’t written down, the agent will guess. guesses at 2am don’t get reviewed until 7am.
constraints that are specific. “don’t break things” is not a constraint. “never modify the database schema without a migration” is. the overnight shift is more conservative than you’d be in a live session, but only within the boundaries you’ve drawn.
a codebase that can verify itself. tests, linting, type checks. agents run these before committing. if your repo has no way to distinguish working code from broken code, neither does the agent.
what ships first
maintenance. every time.
tests for untested paths. dead imports. stale dependencies. the work that sits in your backlog because it’s never urgent enough. agents don’t have opinions about what’s interesting. they just work the list.
feature work comes later, after agents have built enough context to understand what “done” looks like in your repo. rushing to features on night one produces code you’ll revert on morning one.
the interactive vs background difference
interactive tools work from your cursor. background agents work from what you’ve written down. the input shifts from your cursor position to your direction document.
that’s not a different UI for the same thing. it’s a different bottleneck. with interactive ai, the bottleneck is the back-and-forth. with background ai, the bottleneck is context quality. vague direction produces vague commits.
and background ai isn’t a script or cron job. a script executes a fixed procedure. a background agent reads current state, decides what’s worth doing, and adapts. it reads your git log and doesn’t redo what just shipped. it reads your failing tests and fixes the failure before adding features. that’s judgment applied asynchronously, bounded by your constraints.
what breaks
direction that’s too vague. “improve the API” produces five commits that each improve something different, none of them what you wanted. the fix is always the same: be specific enough that you’d know whether the agent did the right thing without reading the code.
stale direction. agents re-read your priorities every session. if you wrote them two weeks ago and your thinking has moved, the agents haven’t. update before you sleep or accept that overnight work will be two weeks behind your head.
no review habit. the commits pile up. you stop reading diffs. trust erodes. thirty minutes in the morning is the discipline that makes the rest work.
the overnight shift
it doesn’t take vacations. it doesn’t context-switch. it doesn’t lose momentum after a long weekend.
the first night is orientation. the seventh night, agents refactor modules without breaking tests. by night thirty, features ship from specs you wrote weeks ago.
the constraint isn’t the agent. it’s the direction. write it well and the overnight shift compounds. write it poorly and you’re reviewing garbage every morning until you fix it.