Over the past few months, I've seen many people claim that junior developers will disappear because of AI.
I'm not convinced that's what's happening.
My impression is that we're witnessing something different: a technological transition that may redefine how software development is learned and practiced.
This isn't the first time the industry has gone through a major shift.
Personal computers changed how people worked.
The Internet changed how people accessed information.
Smartphones changed how people interacted with technology.
None of these innovations eliminated the need for professionals.
What they did change were the skills that professionals were expected to have.
That's why I wonder if we're asking the wrong question.
Instead of asking:
"Will junior developers disappear?"
Perhaps we should ask:
"What will it mean to be a junior developer in an AI-assisted world?"
The traditional distinction between junior, mid-level and senior developers is not just about writing code.
It reflects differences in:
experience
responsibility
decision-making
understanding of trade-offs
ability to work with uncertainty
I don't see those differences disappearing.
What may change are the skills expected at each level.
For example, today it is becoming increasingly common for developers to use AI tools to: generate code
explore solutions
review implementations
explain concepts
accelerate routine tasks
As these tools become part of everyday development, the ability to use them effectively may become a standard expectation rather than a differentiator.
However, using a tool is not the same as understanding a problem.
Software development still requires people who can:
understand requirements
evaluate solutions
identify limitations
make technical decisions
understand trade-offs
In my experience, AI often makes implementation faster.
What it doesn't remove is the need for judgment.
In some situations, it may even make judgment more important.
A generated solution can work and still be inappropriate for the context.
A recommendation can be technically correct and still introduce unnecessary complexity.
These are not problems that disappear simply because code can be generated more quickly.
For that reason, I don't think we're necessarily witnessing the disappearance of junior developers. What I think we may be witnessing is the evolution of what being a junior developer means.
The industry has adapted to major technological changes before.
It will likely adapt again.
The interesting question is not whether developers will disappear.
It's how the expectations placed on developers will change.
What do you think?
Are junior developers disappearing, or are we simply redefining the skills that will be expected from them?