AI Code Reviews Are Making Senior Engineers Worse
You’re approving more and seeing less
AI code review comments are everywhere now.
They started as “nice to have”. A time saver. A safety net. Something you run when you’re tired and don’t want to miss a null check.
Now they’ve become the baseline expectation. The bot comments first. Humans react.
And if you’re a senior engineer, that sounds like a win. Less time squinting at diffs, more time on the “real work”.
Except I’m pretty sure it’s making seniors worse at the job they’re supposed to be best at.
Not juniors. Seniors.
The skill we’re outsourcing
A lot of senior engineering is pattern recognition under uncertainty.
You’re scanning a change and asking: What does this break that isn’t in the diff? What behavior does this imply? What future change did we just make harder? What bad habit are we about to bake into the codebase because it feels convenient today?
Those calls live in the gray area: tradeoffs, risk, and the kind of context you only get after a few incidents and a few postmortems. The same odd edge cases keep coming back, and you start recognizing them early.
AI reviewers are good at the obvious stuff. Sometimes very good.
But the obvious stuff is also the part that trained your intuition. The repetitions. The small calls. The muscle memory of reading code closely enough to notice what feels off.
When the machine handles that, you still approve PRs. You still “review”. You just don’t practice the same skill.
The shift in how reviews feel
This is the pattern on a lot of teams.
The AI leaves 12 comments. Most of them are reasonable. A couple are nonsense. One is a real catch.
The senior engineer shows up and plays referee.
The diff stops being the main object. The AI’s notes become the thing people react to.
You still get approvals and green checkmarks. You still get “LGTM”. But the review is now a negotiation between the author and the tool, with a human stepping in when it gets weird.
Over time, it makes you slower at the kind of review that matters.
Seniors start sounding the same
Another side effect: seniors get more generic.
The AI has a voice. It has preferred phrasing. It has favorite concerns. It nudges teams toward a “house style” that no one consciously chose.
Senior engineers used to have sharper tells in reviews. Not personality quirks, actual engineering preferences.
One person always noticed operability. Another always pushed on API shape. Someone else had a sixth sense for hidden coupling. Those differences were useful. They created healthy friction.
The issue isn’t accuracy so much as posture. It encourages checkbox reviews that feel thorough, even when the hard questions never got asked.
The confidence trap
The most dangerous thing about AI review is how plausible it looks.
You get a wall of feedback and it feels like coverage. You assume the important stuff would have been flagged. You move on.
Senior engineers are supposed to be the ones who don’t get hypnotized by that. We’re supposed to be the adults in the room.
But seniors are also the most overloaded people in the process. More meetings, more cross-team threads, more escalations, more “quick question” pings.
So when a tool offers relief, you take it. You start trusting it the way you trust a teammate who’s usually right.
Then you stop doing the deeper read unless something smells bad.
The problem is: your nose gets worse if you stop using it.
What gets lost
There’s a kind of review comment that’s hard to generate unless you actually ran the code in your head.
“It’s correct, but this will make the next feature painful.”
“This introduces a dependency you’ll regret.”
“This error handling will create support tickets.”
“This change means we can’t reason about state anymore.”
These comments don’t show up reliably from AI reviewers, because they require context, and because they require you to care about the next six months, not the next merge.
If seniors stop writing those comments, the codebase doesn’t immediately collapse. It just gets heavier. It gets harder to change. The team becomes more cautious. Delivery slows down.
And everyone blames process.
A better use of the tool
I don’t think the answer is banning AI review. That’s not happening, and honestly it shouldn’t. The tool is useful.
But teams need to stop pretending it replaces senior review. It replaces some junior-adjacent parts of review. That’s fine. Let it.
What I’d like to see is seniors doing the opposite of what’s happening now:
Read the diff first. Form an opinion. Then look at the AI comments to see what you missed.
Use it like a second set of eyes, not a script you perform.
And maybe accept that part of being senior is doing some “basic” work on purpose, because it keeps you sharp.
The uncomfortable part
The whole pitch of these tools is that they free you up for higher-level thinking.
But higher-level thinking isn’t a switch you flip. It’s built on thousands of small reps. If you outsource the reps, you get the title without the edge.
I’m not worried about AI replacing senior engineers.
I’m more worried about seniors replacing themselves with a thinner version of the job, then acting surprised when they don’t feel as useful as they used to.
I would like to add that a review involve boring coding minutia checks that are better left to AI: dangerous code constructs, security blunders, out of sequence function calls, etc. I have no problem, really, with a first review pass being automated. This already existed before AI.
The second step of a review is to verify that it meets the functional, performance, maintenance and easy administration needs. That is where review time can become exponential with the size of the change, unless the design choices are already well known. With AI's reputation for code duplication and rapid generation of large amounts of code, there is no way a human reviewer can keep up.
Which leads us to the question: if something fails, how to handle it? Maybe the failure is an infrastructure unable to meet the traffic, an application logic problem or missing input validations. Who will know what to look for?
If nobody knows how it works, I can foresee teams rushing to the AI prompt and adding more requirements. It might not take long before conflicts have been created, causing AI output that is just 'statistically valid'.
I still remember the xAI rushes to make their engine both please the boss and still avoid grossly offending output..
"It replace junior reviews": too bad, these are a critical part of training juniors. I see a trend here: junior hatred at its highest..
Otherwise my experience is that to review a large body of code is quasi impossible. I have had cases when I had no choice but limit the depth and scope of my reviews. A review need to be early or in the middle of development to be the most useful.
Reviewing AI generated code must be a hopeless hell.. I am so happy I retired 18 months ago.