DEV Community

Cover image for Human Code Review Is Not the Last Frontier
Joaquin Diaz
Joaquin Diaz

Posted on • Originally published at joacod.com

Human Code Review Is Not the Last Frontier

I found these two articles very interesting: The Self-Driving Codebase and How to Kill the Code Review.

And to be clear, I don't think they are totally wrong, I think they are pointing in the right direction, but I also think they jump too fast from "this is where things are going" to "we are almost there".

That is the part I don't buy.

I'm not anti-AI and I don't think agents are just hype either. I try tools, I use them, I see what works and what not. The progress is honestly better than many people think.

But software engineering in the real world is harder than the clean version of the story, that is my problem with a lot of this conversation.

When people talk about autonomous agents writing software, they often talk as if the main thing left is removing the human from code review. As if once the agents take care of that and humans stop reviewing every diff, then software development becomes mostly an automation problem.

I don't think that is true, I think human code review is not the last frontier, I think it is just the last visible step in a much bigger mess, because most real codebases are a mess.

And I mean that in the most normal, boring, everyday way that anyone with enough years in software has seen many times.

The Reality

Big codebases are full of technical debt. They have different coding styles because hundreds of people touched them over the years, lots of "temporary changes" that were supposed to be improved later and became permanent, dead code because the business changed direction three times, bad abstractions because someone tried to generalize too early, weird edge cases because one big customer needed something five years ago and the company never removed it, missing tests, outdated docs, unclear ownership, and I can go on and on.

So when I read ideas like "review the spec, not the code" or "kill the code review", I get the point, the current review process does not scale well if agents start producing much more code than humans can read, that part is fair. But in many teams, code review is doing more than checking code quality, it is where people bring context back into the change.

The reviewer knows that this ugly part of the system exists for a reason, that another team depends on a strange behavior that nobody documented, that this small looking refactor touches something fragile, which part of the code is annoying but harmless, and which part looks harmless but can break production.

That knowledge is often not written down anywhere, not in the tickets, not in the docs, not in the tests, not in the spec.

A lot of engineering work is not just implementing a clear idea, but discovering what the idea actually means while building it. You start with a requirement, and then you find out:

  • it was incomplete
  • it ignored an old system
  • it breaks an edge case
  • it creates a performance problem
  • it conflicts with another team's flow
  • it sounds simple at the product level but is messy at the data level

So I think some of these arguments assume a cleaner world than the one most engineers actually live in. If we consider that AI currently amplifies any existing structure, we are not in the best of scenarios, and this is where I separate the future from the hype.

The Future

Yes, this is probably the future, agents will keep getting better, human code review as we know it will probably matter less over time.

But that doesn't mean we are close to autonomous software engineering, and even less so in environments where software is hardest: large companies, old systems, regulated industries, critical user facing products, codebases with years of debt and weak ownership. That is a different game.

What works inside a frontier AI company does not automatically work inside a financial institution, that does not mean the frontier companies are faking it (well... at least not all of it), it means their environment is different. They are building the models, shaping the tools, and creating workflows around this new way of working.

But the average company is not in that position. Most companies are not working with clean systems, top tier internal tooling, strong documentation, fast decision making, and teams built around agent workflows. Most companies are still trying to survive their own complexity.

Software Engineering

Writing code is only one part of software engineering, and not even the hardest part. The hard part is working inside messy systems with incomplete context, unclear requirements, old decisions, conflicting constraints, and real consequences if something goes wrong.

That is where things still break down, to me, that is the real frontier, not code review by itself, the real frontier is judgment, context, knowing what matters in this codebase in this company at this moment, knowing when a change is technically correct but still wrong for the system, knowing what to ignore, what to clean up, what to leave alone, and what risk is acceptable.

And that my friends, is what software engineering really is. This is the point that gets lost when the discussion becomes too abstract. Because once you leave the world of demos, mvps, benchmarks, and greenfield projects, software is not just a code problem. It is a history problem, a people problem, a maintenance problem, a tradeoff problem, and I didn't even talk about scalability, maintainability, security and many more important topics.

Where we are

I am not arguing for a conservative view where nothing changes, a lot is already changing, I just think we should be honest about where we really are.

We are getting better at automating code production, we are not yet equally good at automating the deep context that real software engineering depends on.

That is why I don't believe human code review is the last frontier. It's the last place where human judgment shows up before the code lands. A deeper frontier is whether that judgment can be made clear enough, structured enough, and trusted enough that the system no longer depends on humans carrying it in their heads.

Maybe we'll get there, I don't know, or how we'll address the problems I mentioned.

But from where most of the industry stands today, we may be on the way, but we certainly are not there yet, it's not the same thing and it makes a big difference.

Top comments (0)