Jacob Woliver
← Back to blog
3 min read

Code review is now theater

Software · AI

I’ve always appreciated code reviews. Early in my career, they helped me grow in the craft. Even as I became more senior, I liked putting up a PR and reviewing it myself to get a different frame of mind.

But as we have all shifted to nearly 100% agentic development, code review has turned in to empty theater. My current development flow is:

   Design       (human)
     |
Implementation  (agent)
     |
Verification    (human)

The tools are improving for this local loop:

  • Models are tuned for long horizon tasks.
  • Harnesses help lint/test/verify during implementation.
  • Skills help enforce in-depth planning, TDD, etc.
  • Tools like roborev can review and fix work during implementation.

After this local loop though, things fall apart. I push up a change to GitHub and it becomes:

  • CI failed, ask agent to fix.
  • Other team members use their agents to post an immense number of verbose comments.
  • I use agents to read those giant comments and try to discern what is real and what isn’t.

This whole back and forth with humans still in the middle feels pointless. I am not saying code review should go away, the fact that I still get feedback that makes the code better means there is value there. To me though, this means the local loop isn’t right. The local tooling needs to get better so all of this shifts left. The process should evolve:

  • The feedback loop needs to be tighter and autonomous. Other people shouldn’t have to manually trigger their agents for me to then manually review with my agents. Teams need better processes in place. In the same way that we don’t nit on styling because we enforce styles/linting autonomously, the codebase needs to enforce agent reviews with different personas: architectural, quality, correctness, etc. Also updating team skills to codify things that come up over and over. This should all happen locally and autonously so PRs can become something else.
  • If some form of PRs continue to exist, it should be at a higher level of abstraction. Agents summarizing PRs to direct where expertise is needed.

I have written about using Amp. I think the devs don’t have code review at all, they use the Ship button in Amp and have trust whatever you merge to main is well thought out and tested. I like this high trust and high ownership model. It works for them but I’m not sure it generalizes to every team.

Adjacent to the topic of code reviews, there is also a loss of knowledge transfer that used to happen. I could learn an underlying system by being engaged on code reviews. As code reviews and pairing go away, I think we need to solve the intense siloing that is happening on teams.

The current form of code review is broken, something needs to come next for this new era of development.