Copilot is quietly eroding two different skill sets at once. And almost nobody is talking about it honestly.
GitHub Copilot has exceeded 1.5 million paid subscribers. It's safe to say it's now an essential tool as it has integrated into the workflow of many developers a large part of the industry.
I’m not against AI. I benefit from it. But I've watched it create two distinct failure modes that compound silently, and I think we need to name them out loud.
Juniors are skipping the struggle
The struggle is the education. That's the whole point.
When a junior developer struggles, searches on Google for 40 minutes, checks three incorrect answers on Stack Overflow, and then finally understands how closures work - that's part of the learning process. Copilot eliminates this struggle. But this also eliminates the learning.
I have witnessed junior engineers delivering code that they couldn't possibly describe. I don't mean "they missed the details" - they never even understood it. The code was generated by the autocomplete, the tests happened to pass, so they proceeded. The difference between "I authored this" and "I approved this" is massive, but in a PR it's not visible.
→ They're building on a foundation they never poured
→ The bugs they'll create in year two will be stranger and harder to trace
→ Nobody's tracking this skill erosion because output looks fine
The scary part? Their velocity metrics look great. They're closing tickets. Managers are happy. The rot is underneath.
Seniors are skipping the rigor
This is where it starts to get interesting. Seniors aren't immune — they're just failing differently.
There are times when Copilot has written 80% of a function and it's extremely tempting to just skim the review. I've found myself doing this!! The code is pattern-matching as "correct" in my brain so I approve it quicker. It's lazy and I admit I am lazy.
Research indicates that AI-written code has higher defect rates in security-related scenarios. That finding should terrify anyone reviewing AI-assisted PRs with the same speed they review human-written ones. But we soldier on because the code is clean.
→ Seniors are rubber-stamping code that looks idiomatic but hides subtle bugs
→ Review rigor drops because the output feels "close enough"
→ The senior's pattern-matching skill — their actual superpower — gets dulled by overconfidence
Many discussions on developer forums have revealed that subtle AI-generated bugs have made their way into production. These are not extreme failures, but subtle ones. Such as off-by-one errors found during pagination. Or authorization checks that are successful during testing but unsuccessful when exposed to certain race conditions. These are the bugs that require you to search the entire codebase frantically at 2 AM.
The compound effect nobody's measuring
Here are two scenarios that I worry about most, which also reinforce each other. These two failure modes feed each other.
Junior writes AI-generated code they don't fully understand. Senior reviews it with less rigor because it looks clean. Bug ships. Junior doesn't learn from the bug because they didn't understand the code in the first place. Senior doesn't catch the pattern because they've already moved on to the next PR.
This situation creates a feedback loop with no intrinsic correction mechanism. Issues like this don’t come up in your sprint retro or quarterly review. In fact, your DORA metrics may continue to show improvement as the quality of your codebase deteriorates.
What I think we should actually do
I'm not implying that Copilot should be banned. It's already been decided.
However, I believe that there are two things teams need to be intentional about:
→ For juniors: Create protected learning zones. Some tasks should be done without AI assistance — not as punishment, but as training. You don't let a pilot trainee use autopilot on every flight.
→ For seniors: Treat AI-generated code as less trustworthy during review, not more. The fact that it reads cleanly is exactly why it's dangerous. Flip your skepticism dial up, not down.
The tool isn't the problem. The problem is that we adopted it without adjusting any of our quality feedback loops. We bolted a jet engine onto a go-kart and didn't upgrade the brakes. 🔧
So I guess my question is: Have you changed anything about how you review code or onboard juniors since adopting AI? Or did you just turn that thing on and let it rip?