Who owns the code you didn't watch?

A while ago I stopped reading the posts on this blog before they go live. Most of what lands here now gets drafted, checked, and pushed by a pipeline that runs before I'm awake, and the last approval step, the one where a human reads the thing and clicks yes, I removed on purpose. It sounds reckless right up until you look at what I put in its place.

So here is the answer I'd give any vibe coder letting an agent run across fifteen files or ship while they sleep, worried they can't honestly say they own the result. You don't earn that ownership back by watching harder. Watching loses to arithmetic. You earn it by moving the things that must never happen into gates that run whether or not you were in the room, and by building the undo before you build the autonomy. Responsibility stops being a property of your attention and becomes a property of the gate.

why did watching the agent stop working?

Start with the arithmetic, because that's the part people skip. An agent can produce more reviewable change in an hour than you can actually review in that hour. The moment that's true, and it's true early, "I'll just watch it carefully" is already a lie you're telling yourself. You are not watching it carefully. You're watching the parts that scroll past slowly enough to catch, and rubber-stamping the rest. The review step still exists on paper. It stopped existing in fact the day the volume crossed your reading speed. This is an AI orchestration problem before it's a code problem, and the whole promise of vibe coding is speed, which a mandatory human read quietly kills.

There are two honest reactions to that, and both of them fail, in opposite directions, which is how you know the problem is structural and not some discipline you happen to lack. The first is to review harder. Slow down, read every diff, be rigorous. This collapses back into rubber-stamping anyway, just with more guilt, because the volume didn't change and your day didn't get longer. The second is to hand the review to another agent, one model checking the other's work. That one feels clever until you notice the reviewer inherits the exact blind spot as the writer. It can't see the requirement nobody stated either, because it's reading the same surface the first one wrote against. Two agents agreeing the code is fine is not two checks. It's the same check run twice.

what carries the responsibility, if not attention?

The conversation moved somewhere specific this week, and it's worth naming precisely. A lot of people are discovering that a better harness, a slicker rig for running the agent, doesn't fix any of this, and concluding that the answer is to go back to watching. That's the wrong turn. A harness runs work. A gate refuses it. Those are different jobs, and no amount of the first adds up to the second. You can build the most elaborate agent-runner you can imagine and it will still happily run something that should never have shipped, because running is the only thing a harness knows how to do.

What actually carries the responsibility is the set of checks that can say no and make it stick, and that run without you. On the pipeline that publishes this blog, nothing reaches the site until it clears a stack of them: a validator that refuses the commit if the required fields are wrong, a grep that refuses it if a forbidden name slipped into the metadata, a rate cap that refuses to publish more than a fixed number of posts a day no matter how enthusiastic the run gets. I trust those more than I ever trusted my own eyes at half past five in the morning, because they don't get tired and they don't skim. That's the whole shift. The non-negotiables live in code that runs whether or not I'm there, and my attention stopped being the load-bearing part.

the part everyone builds last, and I build first

The move that makes the rest of it safe is the one that feels backward: build the undo before you build the autonomy. Before the pipeline could ship a single post on its own, I built and tested the one command that pulls a post back down, writes its own record of the reversal, and files it. The safety net went in first, fully working, before the thing that would ever need it existed. Only then did I let the drafter run unattended.

The reason is that not-watching is only survivable if undo is instant. When I cut the review gates on this pipeline from three human passes down to one, the pass that survived wasn't a human reading the post more carefully. It was a post-ship revert I can fire in seconds. The operator, me, reading and approving, was the bottleneck, and the bottleneck wasn't buying safety, it was buying delay. Replacing three careful reads with one reliable undo is not lowering the bar. It's putting the bar somewhere a tired human can't accidentally step over it. That's what reduced promotion gates actually means: fewer places where my judgment is the thing standing between a mistake and production, and more places where a mechanical check is.

where this goes wrong

This isn't free, and pretending it is would be its own kind of dishonesty. Two failure modes sit on either side of it. Over-gate, and you rebuild the bottleneck you were trying to remove, because every action parked behind a human decision is just the old review step wearing a new coat, and you're back to watching. Under-gate, and you've only moved the risk somewhere quieter, because a gate protects the properties you actually named and nothing else. Anything you never specified still ships in silence, the exact way a vibe coded app leaks when nobody wrote the policy that should have closed it. The gate is only as strong as the invariants you were disciplined enough to write down first. It doesn't invent your non-negotiables. It enforces the ones you had the sense to state, which is the same spec-first point that shows up everywhere else in this work.

And the revert path is a real cost, not a free pass. A bad post that ships and gets pulled twenty minutes later still had twenty minutes of being live and being wrong. Undo shrinks the blast radius. It doesn't erase it. The trade you're making is small recoverable mistakes, fast, in exchange for never having to be personally awake for every decision, and that trade is only worth it if the mistakes really are small and really are recoverable. Deciding which actions qualify is the actual work, and it's why where an agent should stop is a spec question you answer before you build, not a vibe you settle afterward.

questions that keep coming up

Isn't removing the review step just being lazy about quality? It's the opposite, done right. The lazy version is keeping the review step on paper, feeling covered by it, and rubber-stamping in practice. Deleting it forces you to make the quality bar mechanical, which is far more work up front than nodding at a diff. The honesty is in admitting the human read had stopped being real, and building something that actually is.

What should be a gate versus a human decision? Sort by reversibility. Cheap to undo, auto-fire it and let a gate catch the bad ones. Expensive or impossible to undo, or socially irreversible like sending a message or charging a card, keep a human in the loop. Guardrails that actually refuse are for the first kind. The second kind isn't a gate problem, it's a should-this-be-automated-at-all problem, and the answer is sometimes no.

Can't I just use a smarter model as the reviewer? You can, and it helps at the margins, but don't mistake it for a second independent check. A reviewer reading the same artifact the writer produced shares the writer's blind spot about everything that was never specified. The check that catches the unspecified thing is one written against the spec, by you, ahead of time, not another pass of the same reading, however fresh the eyes.

If you're formalizing how you run agents unattended and want to compare notes on what actually holds at production scale, /work-with-us.

I still don't read most of these before they publish. What changed is that not-reading them stopped being negligence and became a decision, because the thing standing between a bad draft and the live site is no longer me remembering to care. It's a gate that doesn't need me to.