A junior developer shared online that they’re “starting to feel like an idiot” for using AI tools and the post went viral. Thousands of senior developers agreed with them and said “we told you so”.

I think they're panicking about the wrong thing.

The Sky Is Always Falling

Copilot adoption among new developers is basically universal at this point. Juniors are shipping code they can't fully explain. They struggle to debug without autocomplete holding their hand. And senior engineers are treating this like a five-alarm fire.

I feel like we've been here before. Ten years ago, it was Stack Overflow that was the villain. “These young developers can’t do anything without copying from the internet!” Does that ring a bell?

We Never Required Assembly to Write C

Here's the reframe that matters.

When C replaced assembly, nobody demanded that every C programmer first prove they could hand-write machine code. The level of abstraction was raised. The required skills were shifted as well.

→ Assembly programmers thought C devs were lazy.
→ C programmers thought Java devs were sheltered.
→ Java devs thought JavaScript devs were unserious.
→ Now everyone thinks AI-assisted devs are broken.

It's like a recurring cycle. Every generation of developers gets told they don't understand "the fundamentals." The definition of "fundamental" just keeps shifting upward.

That junior who can't trace a segfault manually but can architect a working feature by collaborating with an AI? They have a different skill set. Not an absent one.

Where It Actually Gets Dangerous

I'm not claiming there is no risk involved. There is, but it's not in the direction most people think.

The actual risk is not that junior developers are unable to debug without Copilot. It's that they might never develop the taste to know when AI output is subtly wrong. An imagined function that appears good. A race condition hidden in self-assured code. An architectural choice that works now and collapses at scale.

That's the skill gap we should be concerned about. Not "are you able to write a for loop without using any reference." 🙄

The Skill Bar Moved, Not Disappeared

The juniors coming up right now need to learn different things than I did. They must be taught to critically read code, not simply to write it. They need to develop a sense for when the AI is confidently wrong. They must be able to grasp systems well enough to be the critics of output, not just the producers.

→ Prompt engineering is a real skill, even if the name is silly.
→ Knowing what to build matters more than typing it out character by character.
→ Code review instincts are more valuable than ever.

The standard didn't drop. It just shifted slightly. To be honest, some of these junior developers are shipping work more quickly and acquiring knowledge about how to architect systems sooner than I did, simply because they weren't stuck for six months trying to memorize syntax first.

What Seniors Should Actually Do

If you're a senior dev frustrated with AI-dependent juniors, I get it. But the move isn't to take away their tools. It's to teach them the layer underneath — just enough to build judgment.

Pair up with your mentee on a debugging session when Copilot is disabled. Do it as exposure, not as punishment. Show them what this tool is abstracting away so they can easily spot its mistakes. That’s mentorship. Protecting the old way of doing things is not. 💡

The younger member who made that post about “turning into an idiot” is not broken. They notice a gap, which already makes them stand out from most. It’s the ones who never question what the AI produces that I would be concerned about.

Every generation of developers looks soft to the one before it. Every generation turns out fine because the work itself forces growth. The times change. The thinking doesn't.

What's the one skill you think AI-assisted juniors should learn the hard way, without any tools helping them?