Everyone blames AI coding tools for ruining junior developers. Nobody talks about what it's doing to the seniors.
I've been thinking about this for a while. The dominant narrative is that Copilot is creating a generation of developers who can't code without autocomplete. But I think we're looking at the wrong level of the org chart.
The real problem isn't generation
As of November 2023, GitHub Copilot counted with more than 1.8 million paid subscribers. There are immense amounts of developers relying on AI code every day.
Research indicates that AI assistants can increase a team’s written output but not necessarily its quality. Let’s assume that sinks in now. The additional volume of code that is less optimal must be identified and fixed somewhere. And that somewhere has always been assumed to be in the code review.
Seniors are rubber-stamping AI slop
This is what I continue to notice. A junior opens a PR with Copilot-generated code that mostly works. The senior reviewer skims it, sees it passes CI, and hits approve.
Prior to Copilot, that identical senior would have detected the strange abstraction. They would have identified the function that does three things. They would have highlighted a comment outlining why the solution was incorrect, rather than just that it was wrong. That comment served as the complete mentoring system. 🔥
Now? They too are feeling the pressure to ship sooner. They're glossing over the details because the AI handed them an implementation that was "close enough". They're also skipping the deep thinking because the AI gave them something "good enough." The review becomes a formality.
Speed is the wrong metric
The conversation around AI coding tools has shifted from "will it replace us" to "is it degrading our skills." But even that framing is too broad.
Junior developers who are utilizing Copilot are not yet an expert. They're reading the suggestions, accepting some, rejecting others. They're building intuition, even if it's a different kind of intuition than we built.
Seniors using Copilot are unlearning. They already had the deep knowledge. They already understood the tradeoffs. Now they're outsourcing exactly the kind of thinking that made them senior in the first place.
→ A junior who accepts bad AI code doesn't know better yet. That's expected.
→ A senior who approves bad AI code does know better. That's erosion.
→ The junior loses a learning moment. The senior loses a muscle they spent years building.
The mentorship gap is the real cost
The most experienced senior colleagues I've had the opportunity to work with approached the code review as if they were teaching something. For them, each Pull Request was an opportunity to pass on knowledge. Every remark was a small masterclass on design, naming, edge cases, or system thinking.
When seniors stop doing that work, juniors don't just miss one lesson. They miss the entire feedback loop that turns them into future seniors. That pipeline breaks silently. You don't notice it until two years later when nobody on the team can debug a production issue without asking ChatGPT. 😅
This isn't an anti-Copilot take
I rely on AI coding tools. They're really helpful for boilerplate code, experimentation, or when you're stuck. I'm not saying we should do away with them.
I am here to say that being a senior developer is not a job that will be automated away, because the hard parts of being senior were never the parts a computer could do. It was not about typing speed. It was about judgment, and mentorship, and staying "no, this isn't good enough" when the CI is green.
Copilot doesn't make juniors dumber. It just becomes dangerously easy for seniors to refrain from the work that made them seniors in the first place. And that's the quiet part out loud. 🎯
So here's my question: has AI tooling changed the depth of code reviews on your team? Are seniors still teaching through PRs, or has review become a rubber stamp?
Top comments (1)
The diagnosis is right: a junior who accepts bad AI code doesn't know better; a senior who approves it does.
What I'd push on is the assumption underneath: that PR review is where senior judgment should live. It used to be, because the spec was implicit, the architecture was tribal knowledge, and the only place a senior could intervene was after the code existed. The review was the choke point because nothing earlier was structured enough to be reviewable.
When code generation gets cheap, the senior reviewing a PR is now reviewing an artifact of a hundred upstream decisions the AI made silently from a one-line prompt. Catching the bad abstraction at review time means catching it after it has already shaped the rest of the diff.
What helps is moving the senior touchpoints upstream. Senior judgment goes into spec authoring (what's out of scope, what are the failure modes, what should this never do), into architecture and conventions documents the AI reads on every session, into the rubrics that downstream review runs against. PR review becomes a quick check that the spec was honored, which is smaller and more mechanical than the review seniors used to do.
This doesn't erase the mentorship gap. It moves where the mentorship happens. A senior teaching a junior to author a spec ("here's the question you didn't ask, here's the failure mode you assumed away") is doing the same knowledge transfer the old PR comment used to do, earlier in the pipeline.
The team where this breaks is the team where seniors didn't move with it. They kept reviewing PRs the old way, found themselves rubber-stamping because the work had become deterministic, and concluded that AI made them lazy. Some of that is real. Some of it is the senior judgment having quietly relocated to a place they weren't watching.
So to answer your closing question: yes, review has become a rubber stamp on most teams I've seen. But the fix isn't reviving the old review. It's building the upstream structure that lets senior judgment land where it now matters.