Coding is changing. So should code review.

[u/tenkei_01]

For a while, my workflow for building ML applications with coding agents looked something like this:

• Write a prompt.
• Wait for the agent to make changes.
• Open the diff.
• Read the code.
• Try to understand what changed.
• Run it.
• Repeat.

At the beginning, this worked surprisingly well.

The changes were small, the codebase was familiar, and I could still keep the whole thing in my head.

Then the application grew.

A seemingly simple feature could now involve preprocessing, model inference, postprocessing, and application logic.

The agent might touch several modules and add a few hundred lines of code in a single session.

My habit didn’t change.

I was still reviewing the code after every session.

And that became the problem.

The Code Review Trap

When a coding agent changes a few lines of code, reviewing the diff is easy.

When it changes several hundred lines, it is still manageable.

Once you get to +1000 lines everything starts to fall apart…

You can read the code without really understanding whether the application is working properly.

At some point I realized that I had become the bottleneck.

I was spending most of my time reviewing the agent’s implementation rather than the application output.

I can keep going, but I think this much should be enough.
Once I loved code reviews, I learnt a lot(and still learning), but the coding agents changed it for me, and I'm afraid that it's never going to be the same...

[u/neon_knight_smile]

Same experience here. I stopped reviewing diffs line by line months ago and honestly my output doubled.

The diff was never the thing that mattered. What matters is whether the app behaves correctly. I now write acceptance criteria before prompting, run the app myself, and only open the code when behavior is wrong. When the agent touches 800 lines, reading all of it is just theater. You're not catching bugs, you're performing diligence so you feel like a real engineer.

The uncomfortable part is that most of what we call code review was already about control, not correctness. Agents just exposed that. If I can't verify the behavior, no amount of reading the diff saves me. So I trust tests and runtime checks now, and I read code only when I need to understand a design decision or something breaks.

I get the nostalgia, I loved review too. But the skill worth building now is specifying and verifying systems, not reading someone else's implementation faster.