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?