Here’s a story I’ve seen more times than I’d like to admit. Someone notices something that looks like a bug, so they ask an agent to fix it. Another agent reviews the change, and it looks great. Clean code, tests passing, a nice description. It gets merged. And then someone finally asks: wait, why did we change this?
Because it wasn’t a bug. It was a decision. Somebody made it on purpose, for a reason that was never written in the code.
The implementation was fine. The work was a waste, because nobody wanted it in the first place. And no amount of automation caught it, because the code was never the problem. The intent was.
The wrong bottleneck
Right now it feels like everyone is betting on AI software factories: agents that pick up a ticket, write the code, open the pull request, review it and ship it. And part of that is great. The models are getting really good, and there are tools that catch things a tired human would miss at the end of the day. I’d be lying if I said I don’t want that help.
But writing code was rarely the real bottleneck. Understanding what to build, and knowing that what we built is right, is the slow part. So when we speed up the part that wasn’t the bottleneck, we don’t actually go faster. We just pile up more work in front of the part that was.
More pull requests than anyone can read. And when people can’t keep up, review turns into a rubber stamp. The human in the loop is still there, technically. They’re just not really looking anymore.
I think we lose something bigger than quality there. Code review was never just a gate. It’s one of the few moments when two people look at the same thing and share what they know. It’s how context moves around a team.
What I’d fix first
I don’t think the answer is to stop automating. I think it’s to solve the confidence problem before we build a bigger pipeline of pull requests.
- Intent before implementation. Every task an agent picks up should carry the why, not just the what. And when something is a deliberate decision, it should say so, somewhere both people and agents can see it. That alone would have saved the fix that wasn’t a fix.
- Split the review. Let the machines do what they’re great at: correctness, tests, security, consistency. Let people focus on the questions machines can’t really answer yet. Should this change exist? Does it fit where we’re going?
- Measure confidence, not volume. Stop celebrating the number of pull requests. Look at how often things get reverted, reworked or quietly undone, and how long it takes someone to understand a change.
- Stay close to each other. Talk more. Share what you built. Rotate who reviews what. Sketch an idea by hand before anyone, human or agent, starts building it. I say this as an introvert who isn’t asking for more meetings.
I’m not against software factories. I think they’re coming either way. But the foundation matters: fix quality and alignment first, and the factory becomes something we can actually trust.
This is the team version of something I wrote about before, in Don’t Automate the Fun: what happens when I hand too much of my own thinking to AI.
I don’t want us to automate away the moment we stop and ask: is this actually what we want?