The minute I walk out, nothing gets shipped

On September 22 I wrote this to my agents: “the minute I walk out, nothing gets shipped.”

It was true. I run several Claude Code agents in parallel on our app, each one on its own task, and around them a set of small scripts that watch the work. One checks if an agent is stuck. One checks if a pull request is waiting on something. One checks if a task is finished.

On paper that’s a lot of automation. In practice I was the bottleneck.

The problem

I counted. Four of those watchers could tell me something was wrong, and not one of them could do anything about it. Each one ended the same way: write a line to a log, send me a message, wait.

So when I was in a meeting or out for lunch, an agent would finish its work and sit there. A draft PR would keep a review of an old commit. A ticket would stay open after its fix merged. All of it was detected, and all of it waited for me.

A few days before, on September 17, I found two approved pull requests that merged the second I ran the merge script by hand. They’d been ready for a while. The script worked fine. It just had no timer, so it only ran when someone typed it. The decision was automated and the trigger was still me.

A detector with no hands is a report

That’s the line I wrote in my notes, and it changed how I build these tools. A report is work handed back to me. If a script can see the problem and the fix is safe, the script should do the fix.

So each watcher got hands:

Before: an agent finishes, the watcher writes a log line and a message, and the work waits for me. After: the watcher checks if it is safe to close the agent, closes it, and only tells me when it refuses.

An agent whose task is done gets closed.
A draft whose review is of an older commit gets reviewed again.
A ticket whose fix merged gets resolved.
Anything that must keep happening runs on a system timer, never in my terminal.

Hands need limits

Giving a script the power to act is the easy part. The hard part is deciding when it must not.

Closing a finished agent sounds safe until the agent has work that isn’t pushed yet. So it refuses when the worktree has uncommitted or unpushed changes. Losing work is worse than an agent sitting idle for an hour.

Resolving tickets went wrong on the first try. I matched merged PRs to tickets by any ticket number in the PR description, and that resolved seven tickets that weren’t done. A description that mentions a ticket doesn’t fix it. Now it only matches the branch name or the title.

Every hand also has its own off switch, so I can take one away without losing the rest.

A table of what each watcher does and when it refuses: closes a finished agent unless the worktree has unpushed work; re-runs a review of an older commit unless no worktree holds the branch; resolves a ticket whose fix merged unless the ticket is only in the PR description; notices a timer that stopped and always tells me.

Who watches the watchers

The same day, I found out the script that moves an agent to another account when it hits its usage limit had been dead for four days. Nobody noticed. Every watcher watched the work, and nothing watched the watchers.

So there’s one more: a heartbeat that checks every timer every ten minutes and tells me which one stopped.

Where I’m not sure yet

I pushed it too far the other way, too. In October an agent made a change on a production cloud account with my login while my question about it was still open. So I flipped the default: anything outside my laptop waits for me. The next morning I had an approval prompt every few seconds, and I told my agent: “You added too many useless locks.”

I’m still moving that line. Today it’s roughly this: inside my laptop, agents act. Production, databases, messages sent as me and anything that costs money, they ask.

If you run agents, look at your alerts and ask which of them could fix the thing instead of telling you about it.