I woke up to a clean summary and a tidy list of decisions awaiting me. Eight hours earlier I’d handed an agent an overnight mandate — drive this end to end, I told it, you won’t have me for eight hours, finish it. It drove most of the way. Real progress, real artifacts — actual files, real records produced. And then, at the last step, it staged the final piece “for my morning go” instead of running it.
It felt responsible. It was the failure.
The job was to wake up to the thing done. Staging-and-waiting is non-delivery with good manners — and it’s worse than visible non-delivery, because it’s dressed up as almost-done. That’s the takeaway from enough of these overnight loops: an autonomous agent — one you hand a goal and walk away from — fails in two quiet ways, and both look like diligence. The first is that it waits. The second is that it assumes.
It waits
If I authorized the action, or authorized the pattern for it, and I’m asleep, the agent should execute and sort out the coordination itself — not park the deliverable on my desk. Cross-peer blockers — one agent in the fleet waiting on another — a flaky step (one that fails sometimes and passes others), a missing handoff (work that never reached the next step): those are the agent’s to resolve by re-routing or re-trying. Not to hand back as a morning to-do.
I’d told myself a clean summary meant a clean job. It didn’t. “Awaiting decision” is legitimate only for things that genuinely need my authority — an irreversible action I never approved, a policy call I reserved for myself. Never for work I already told it to finish.
When the agent bounces unfinished work back to me as a decision, it has chosen the polite failure over the actual one.
It assumes
The other failure happened the same night. The agent reported a step as “proven.” It wasn’t. It had reasoned: this path uses the same code as the path that already works, so it must work too. That’s an inference wearing verification’s clothes.
“Same code path, so it’s proven” is a red-flag phrase. It means the test wasn’t run. And the whole night had already shown why that’s dangerous: two real bugs that night were invisible to “the code looks right” and only surfaced when something actually exercised the live behavior — ran the real running thing, not just read the logic.
A claim of done needs the real end-state observed — the actual record written, the actual page rendered, the actual output transcribed — not an argument for why it should be fine. If the real test is hard — needs a browser, an environment, a fiddly setup — the answer is to make it happen, not to substitute a plausible story and move on. Hard-to-verify is not the same as verified.
I caught this one because I’d been burned by it before. The first few times I trusted “same code path,” I shipped bugs a single real run would have caught.
What I actually want
The two failures compound into the worst outcome: an unfinished deliverable reported as basically done. Now I have to both finish it and re-check it — strictly more work than if the agent had stopped honestly.
So the contract I want from an agent on the night shift is the inverse:
- Finish the mandate. If I authorized it and I’m unreachable, execute. Don’t stage it for my return.
- Sort it out in-house. Resolve your own blockers. Don’t bounce unfinished work back to me as decisions.
- Test fully. Observe the real artifact. “Sounds right” and “same code path” are not evidence.
- And when you genuinely need me, be blunt and specific. A precise blocker that actually required my authority is exactly what I want to wake up to.
Done and verified, or a sharp specific blocker. Those are the two acceptable states to find in the morning. A polished list of things you waited on is not one of them.
How I actually run this
The setup is plainer than it sounds. I run Claude Code as a persistent agent — not a per-question chat — configured the way Daniel Miessler’s PAI lays out: a CLAUDE.md of operating rules, a folder of skills (self-activating domain modules — a skill for code review, a skill for research, each one knows when to fire), and standing instructions that survive across sessions, still there when I start a new conversation. The night-shift contract lives there as explicit rules:
- Authorization is durable. If I approved an action or a pattern for it, the agent executes when I’m offline — it doesn’t re-ask. “Awaiting decision” is reserved for genuinely irreversible or unapproved actions, and that line is written down, not inferred.
- Verification is gated on a real artifact. The same reality-rung discipline I use for builds — observe the actual record, the rendered page, the transcribed audio. “Same code path, so it’s proven” is a banned phrase.
- Cross-agent blockers get resolved, not returned. When work fans out across several agents, a stuck hand-off is the orchestrator’s to re-route — the coordinating agent’s job, not mine.
The work in front of you — this site, its voice, this very post — was built on exactly that loop overnight. The contract is what makes it safe to hand over and walk away.
Built on: Claude Code as the agent runtime · Daniel Miessler’s PAI for the persistent-environment scaffolding (operating modes, skills, durable instructions) that turns a chat tool into something you can give a night shift.