Your coding agents are faster than you can follow
· 9 min read TL;DR
- Fast output made it easy to lose track of what I’d agreed to and what had actually been checked.
- I needed clearer reasons for changes, evidence I could question, and a record I could return to.
- Requiring approval for everything made the process exhausting. The important decisions needed more attention; routine work needed room to continue.
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. The agents write most of the code, but I still decide what we should build, question the approach, and own 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:
“Six of seven observed; usage reporting needs API-invoked agents…”
The submission behind that decision was explicit: six conditions had been observed against the running server; the seventh had tests but no real run behind it yet.
That distinction is why I keep the decision. The record shows what I accepted and what remained unproven. Months from now, that sentence will still know more about that feature than I will.
The human becomes the bottleneck, on purpose, at the decisions that authorize work and accept its result. The agents can suggest designs and check their work. I still own the decision to proceed, including the limits of what the evidence proves.
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 ledger records eleven operator decisions in a single day, nearly all of them about my little tracking tool rather than the work 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. Some problems I caught myself. Another was caught by an agent that questioned the permission it had been given.
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.”
Both stories turn on the evidence in front of the agent. In the first, stale documentation supported a design aimed at the wrong target. In the second, the agent questioned stale permission instead of using it. The difference matters: agents need to challenge the evidence too. I remain responsible for what I authorize, but I won’t catch every mistake myself.
Where this leaves you
Agents will keep getting faster. You will not.
I can’t read, question, and verify their work at the speed they produce it. If I try to match their pace with quicker approvals, I end up trusting things I haven’t understood.
I can still give the agents room to work. But the decisions that authorize consequential changes and accept the results need my actual judgment, with evidence and a reason I can return to.
The bottleneck is you, and it should be. Not everywhere. At the decisions whose consequences you own.
I’ve written these lessons down as Operator-Led Software Development, a way to stay responsible for work that agents can do faster than we can follow.