Code Review Is a Conversation, Not a Checkpoint

A while back I wrote about why manual PR review still matters in the AI era. That one was about you. Your judgment, your eye for a bad abstraction, the skills that quietly rust when you stop reading code.

This one is about everybody else on your team.

Here's the thing I keep coming back to: review was never just a quality gate. It was the main spot where engineers actually talked to each other about the work. And an AI can summarize a diff and flag a sketchy line all day, but it can't have a conversation with your team about why the code looks the way it does. Hand the whole review to a bot and you keep the green checkmark while quietly losing the conversation. That's a bad trade, and most teams don't notice they made it.

The Part AI Quietly Deleted

An AI review is a monologue. It reads your diff, tells you what it thinks, done.

A human review is a thread. Someone asks why you went with this approach. You explain the constraint they couldn't see from the diff. They go "oh, what about just doing X instead," and half the time X is better. You realize the edge case they're nervous about is actually real. By the end, two people understand the change instead of one, and the codebase has two owners instead of one.

That back and forth isn't a side effect. It's the whole point. Strip it out and you're left with a faster gate and a team that knows a little less about its own system every week.

It Keeps Your People Skills Sharp, Not Just Your Coding

Nobody's career stalls on syntax. Careers stall on the human stuff.

Writing a review comment that's clear, useful, and doesn't make the author feel dumb is a real skill. So is explaining a tradeoff in plain words. So is disagreeing with a senior engineer without it turning into a thing, or pushing back on a junior in a way that teaches instead of crushes.

You practice all of that in review, comment by comment. Every one is a tiny rep in writing for an audience and making your case. Let AI draft your reviews and AI read them, and you stop doing the reps. It's not just your coding that gets flabby. The collaboration muscles go too, and honestly those are the harder ones to build back.

A Team Learns by Reading Each Other's Code

The fastest I've ever leveled up on a team was just reading PRs from people better than me.

You see how a senior structures a genuinely hard change. You catch a pattern you'd never have reached for on your own. You watch someone handle an error case you would've shrugged past. None of that is in the ticket. None of it is in the docs. It only shows up in the diff, right at the moment the decision got made.

Review is also where ideas get better in real time. You open with one approach, a teammate floats another, and what ships is something neither of you would've written alone. That's brainstorming wearing a comment thread as a disguise. An AI reviewer can't pull your team into that. The best it can do is hand one person an opinion.

And there's a mentorship layer underneath all of it. Juniors grow when someone who cares leaves thoughtful feedback. Seniors sharpen up because they suddenly have to explain the thing they "just know." Automate the whole loop and you cut the main wire a team uses to make itself better.

Humans Catch the Bugs That Need Context

Give credit where it's due: AI is great at the mechanical pass. Null checks, an obvious off by one, a missing await, a branch nobody handled. Let it do that. It's fast and it never gets bored.

The bugs that actually hurt are the ones that need context the diff doesn't contain.

This change is technically fine, but it breaks an assumption another team has been quietly relying on for months. This is correct today, but it won't survive the migration we all agreed to back in March. This matches the ticket perfectly, except the ticket misunderstood what the customer wanted. None of those are "is the code right" problems. They're "is this even the right thing to build" problems, and answering them takes someone who knows the history, the roadmap, and the people. That knowledge lives in your team, not in the model.

Use AI to Prep the Review, Not to Be the Reviewer

To be clear, this isn't me telling you to stop using AI in review. I use it constantly.

I let it summarize a big diff so I walk in already oriented. I let it flag the mechanical stuff so I can spend my actual attention on intent and design. I let it suggest test cases I would've lazily skipped. It makes the human part of review better by clearing out the noise first.

The line I try not to cross is letting it become the reviewer. The summary is my warm up, not my verdict. The flags are a checklist, not a sign off. The approval, and the conversation that earns it, stays with a person. Me.

Wrap Up

Manual review keeps your own skills sharp. Human review keeps your team alive.

Communication, mentorship, shared context, that half-baked idea that turns into a better design once two people poke at it. All of that happens in the space between two engineers staring at the same diff. AI doesn't fill that space. It just makes the gate faster, which is not the same thing.

So use the tools. Let them prep the review, clear the noise, catch the easy stuff. Then go have the conversation anyway.

The checkmark was never the point.