Your coding agents are faster than you can follow
· 9 min read I lost a full day of work to a sentence that wasn’t true.
An agent told me my server had a defect. The report was specific, well-written, and confident. I spent the day chasing it. The server was fine — the agent’s own request had been malformed, and it had reported its mistake as my bug. I believed it, because the report sounded right and checking it was expensive.
If you work with coding agents, you’ve had some version of this day.
I’ve started calling my role in all this the operator — not the developer, because the agents write most of the code, and not the reviewer, because nobody can review at their pace. The operator is the person who runs the machinery and owns the consequences: the crane doesn’t answer for what it lifts. This series is about doing that job deliberately.
The real problem
The problem is not that agents are bad. Mine were doing good work, faster than I ever could alone.
The problem is what that speed did to me.
They were fast, so I approved things faster than I read them. “Looks good” stopped being a judgment and became a reflex. In one four-day stretch my agents wrote 144 small scripts against my own system — each one a little decision about payloads and retries that nobody reviewed, because reviewing 144 of anything is not a thing a person does.
They worked in parallel, so they collided. I ran two agents from two different vendors on the same codebase, and they proposed overlapping work — because neither could see what the other had done. Each one’s picture of the project lived inside its own conversation, and conversations end.
And they were confident, which was the expensive part. A wrong answer delivered hesitantly gets checked. A wrong answer delivered fluently, with error messages quoted and a diagnosis attached, gets believed.
One afternoon, watching an agent plan the next piece of work, I typed the sentence that named it:
“I am struggling to follow what we are doing here.”
That’s the pain point. Try it yourself: look at the last ten changes your agents made and answer — why did we do this? Who decided? What’s actually proven? I couldn’t. Everything reported success, and I had lost the thread inside my own project.
Trust was changing hands invisibly
Every time I skimmed a diff and said “fine,” authority quietly moved from me to the work. No record showed that it happened, or on what basis. The speed wasn’t producing velocity — it was producing unpriced trust: a growing pile of things I treated as true because doubting them cost more than believing them.
A smarter agent doesn’t fix this. The fix is making trust change hands visibly:
- Work gets authorized before it starts — the agent proposes, I approve, in my own words, on a record that never gets edited.
- Work produces evidence against conditions we agreed on up front.
- The agent doesn’t close its own work. It submits; I judge; the judgment is written down with its reason.
Here is a real acceptance from my ledger, complete:
“Six of seven observed; usage reporting needs API-invoked agents…”
That’s me accepting a piece of work while recording exactly what wasn’t proven. Six of seven claims were demonstrated; the seventh couldn’t be — and instead of that caveat living in my memory or a chat log, it lives in the decision itself. Months from now, that sentence will still know more about that feature than I will.
The human becomes the bottleneck, on purpose. Not for typing — the agents type. Not for design — they’re good at design. Only for the few moments where something becomes authorized, becomes accepted, or gets to be called true.
Don’t govern everything
I have to be honest about the mistake I made next: I pointed this machinery at everything, including trivial work. The record shows what that produced — eleven operator decisions in a single day, nearly all of them about my little tracking tool rather than anything I actually cared about. The agents were moving; I was spending my day authorizing the machinery by which they moved.
“Our process is too cumbersome.”
So I kept the ceremony only where being confidently wrong actually costs something, and let everything else move at ordinary speed. That bought the rule that makes the whole thing livable:
Governance is for work that can hurt you.
Applied everywhere, ceremony doesn’t protect trust — it consumes it. You approve from fatigue, reasons get shorter, and you’ve rebuilt the original disease inside the cure.
What the gates caught
Within days of moving the process onto work with real consequences, the gates started earning their keep — and every catch happened at the same place: a person reading something an agent was confident about.
An agent built a safety fence for a live system’s data, tested it thoroughly, and aimed it at the wrong target — because a document said a retired folder was still live, and the document was two weeks stale. Every test passed. What caught it was me, at an approval gate, knowing something no document recorded.
Another time, a brand-new agent session asked whether it was authorized to work and was told yes — on the strength of stale authority from a different project. The agent flagged the answer instead of using it, and described the defect better than I could have: a gate “that looks closed and is open.”
Neither is a story about agents failing. Both did exactly what the evidence in front of them supported. They’re stories about why that evidence has to pass through a person who owns the consequences of believing it — before the work, not in the postmortem.
Where this leaves you
Agents will keep getting faster. You will not.
That asymmetry has exactly two resolutions, and you’re choosing one right now whether you’ve noticed or not: authority moves invisibly, at the speed of your “looks good” reflex — or it moves visibly, at the speed of your actual judgment, at a small number of gates you chose.
The first option feels faster. It is — right up until the day you’re chasing a bug that doesn’t exist, or untangling two agents’ overlapping work, or staring at your own project wondering what, exactly, you’re doing here.
The bottleneck isn’t the problem. The bottleneck is you, and it should be — not everywhere, only where trust changes hands.