CODE IN TOKYO

The Era of Humans Reviewing All AI-Generated Code Is Ending

Bottom line: doing reviews the way we always did doesn’t make sense anymore.

Even if AI makes implementation 10x faster, if a human still has to read every line, the human becomes the bottleneck.

In other words:

The end-to-end speedup is barely there.

And in practice there are extra costs:

So the complaint “AI feels faster, but total productivity is unclear” makes sense.

But that’s because we haven’t changed the assumptions on the review side.

Porting human review as-is doesn’t scale

Code review today is built around the assumption that humans write the code:

If we keep this culture in the AI era, only the reviewers go to hell.

AI doesn’t get tired, so it can generate massively. But human review speed doesn’t change.

The result: organizations are no longer waiting on implementation — they’re waiting on review.

This has happened before

Back when humans wrote assembly directly, there was a real debate:

“Can you really trust the code that a compiler emits?”

Today, nobody reads the compiler’s output line by line.

When you write C, you trust:

Humanity has done this before — abandoned the culture of reviewing every layer.

Of course, compilers and AI are not the same. Compilers are deterministic, and their output is formally guaranteed. AI is probabilistic, producing different outputs each time.

It’s not a perfect analogy.

But the direction — “humans eventually stop visually inspecting every output” — is, I think, the same.

Let AI review AI

So is review unnecessary? Of course not.

The shift is from “humans read everything” to “AI reviews AI.”

Asking the implementing AI “how does this look?” doesn’t work. It’s lenient with itself. AI is soft on its own session.

In the same context, when you ask “is this OK?”, it tends to justify whatever it just produced.

That’s why Anthropic officially recommends running a separate “strict reviewer agent” alongside the implementation agent. (Claude Code’s subagents are a clean example.)

The key is to:

We’re starting to see role splits like:

It looks a lot like a human team.

The human role shifts to “auditor”

That said, we can’t fully trust AI yet. So the human role doesn’t disappear.

But it changes.

From “the person who reviews everything every time” to “the person who audits overall quality.”

Concretely, on a regular cadence (weekly, every 10 PRs, before each release), look at:

The whole system, in other words.

This is partly quality assurance. But it’s also how humans keep their understanding of the system intact.

Why does this matter? Because AI multiplies code very quickly.

Left alone, you get:

AI is good at local optimization. Long-term architectural coherence is still its weak point.

So the human role shifts toward managing:

Summary

In the AI era, “humans review everything” makes review the bottleneck.

What we need is a role split:

Just as humanity once accepted compilers, AI code generation will eventually move to a “trust by default” world.

We’re in the transition period now.

And in that period, how to design the audit layer is going to be the next competitive battleground for engineering organizations.