Around mid-July, when OpenAI, Anthropic and Google were all pushing in the same direction, the conversation got loud: autonomous coding agents were going to write your software for you. I ship backend systems for a living, and I use these agents every day. I like them. They let us build and deliver faster.
But "faster" is where the honest part of this story begins.
Faster is not free
Rush a feature and you pay for it in tool quality. Less time on a single problem, and the code shows it. We're in the age of AI, but it isn't mature yet, everything moves quickly, agents included. So the interesting question isn't whether the agent can write the code. It's what you do with the time it gives back.
Our answer: we spend that time reviewing instead of typing.
The old math looked like this. A feature took about a day to build, then a few hours to review, call it a day and a half to two days end to end. Now we solve the same problem in hours, review it, and finish in less than a day. The saved time doesn't vanish into a velocity chart. It goes into other work, and quality stays where it needs to be.
Agents reviewing agents
What works best for us is having agents review each other. One coding agent writes. A separate review agent checks it. Because they reason differently, the combined output is genuinely better, fewer problems, more thought-through code. By the time a pull request reaches me, a strong reviewer has already been over it. My job becomes the final pass: polish, not archaeology.
I want to be precise about the limits, because the hype isn't. A review agent still makes mistakes. It can leave a fault in place, or miss a part. It's no guarantee. But set that against what actually happens in human review of a large change: tens of files modified, hundreds of thousands of lines. As a human, chances are you don't give every part enough attention. So the second agent isn't only a guardrail. It's a way to make sure the parts you'd skim get read in detail.
«It's not just you, or someone trying to remember a part of the software that was written months ago. It's a plus-one reviewer, and it's not a regular reviewer, it's a strong one.»
The memory nobody on the team has
The strongest case for this isn't small features, where the agent just saves you a bit of time. It's the shape of the projects we actually run.
We're not talking about indie side projects. These are commercial builds that take about a year, with teams split across backend, frontend and various product areas. Say four backend engineers work on a tool. One of them writes a feature in month one or two. By month ten or twelve, that same developer has forgotten most of the detail. They'll still hold the most expertise on it, but not 100 percent. And often it isn't even them doing the review; it's another engineer who was never in that code at all.
That's where a coding agent with full project knowledge changes the economics. It isn't limited by human memory and it retrieves information instantly. By month ten or eleven, an intermediary review agent becomes the institutional memory nobody on the team individually holds. Without it, reviewers burn enormous amounts of time digging through the codebase, trying to recall who built what, chasing colleagues, re-reading comments and documentation. An agent indexes and retrieves that context on the spot.
I'll be honest about one thing: I can't hand you a single dramatic war story where the agent caught the one bug a human missed. Same reason as everything else, I'm human, I don't remember every incident in that kind of detail, and some of it I can't share. But the pattern is real and repeatable, and that counts for more than one anecdote.
Where I draw the line
None of this removes the fundamentals. You still need unit tests and integration tests. You still need a human to own the logic that matters. The agent is a plus-one on top of that, not a replacement for it.
So the line I draw is simple. Let the tool do the work it does well, writing a first pass, and reviewing with a memory none of us can match. Then own the final review yourself. The reward for using agents well isn't shipping without thinking. It's arriving at review already knowing the code has been read once, carefully, by something that remembers month one when the rest of us don't. This capability will improve fast. Until it's mature, the discipline around it is the product.
