AI doesn't replace junior developers. But it changes how we train them.

The startups I talk to don't want to grow anymore. The equation is tempting: a senior team equipped with AI promises to produce as much as a team twice its size. Junior developer hiring has collapsed, down 67% since 2022. In France, 26% of tech leaders have already cut junior positions.

On paper, the equation holds. In practice, nobody has measured the real productivity of a full-senior + AI team over time. What we do know is that the equation ignores one parameter: in 5 years, who will have built the skills to take over?

AI speeds up production, not learning

I built POCs in languages I didn't know using AI. Working prototypes, in a few hours, in technologies I'd never touched. The prototype worked. My understanding of the language? Still close to zero.

This isn't an isolated anecdote. On a recent engagement, I worked with an engineering school intern. Technically, she delivered. But when asked to explain her own code, she couldn't. The code ran fine. She couldn't explain how.

Anthropic measured this in a lab setting: developers learning a new library with AI assistance scored 17% lower on comprehension than those coding without it (1). The speed gain wasn't statistically significant. A single study, a specific context, but the signal is consistent with what we see on the ground. Debugging is the skill most affected.

MIT Media Lab documented a related effect they call "cognitive debt" (2). When AI does the work, the brain engages less. Up to 55% reduced neural connectivity. 83% of participants couldn't quote from essays they'd just written with AI. Preliminary research, not yet peer-reviewed, but the direction is clear.

In the teams I work with, AI speeds up production. It doesn't speed up competence. For juniors, the effect is even more pronounced. We're producing developers who can generate code but can't tell when it's wrong.

A counter-argument keeps coming up: soon we won't read code at all. AI will generate, test, deploy. Judgment about code will become irrelevant. Maybe. But even in that scenario, someone needs to understand what the system does, why it does it, and when it gets it wrong. Judgment will shift from code to architecture, security, production behavior. It won't disappear. And nobody learns it from a prompt.

What a team loses when it stops hiring juniors

There's an effect that numbers don't capture. Teams that haven't hired juniors in a long time end up turning inward. Seniors optimize what they already know instead of questioning it.

At Jolimoi, what I loved about juniors was that they wanted to conquer the world. They asked questions nobody was asking anymore. That energy is missing in teams that have stopped hiring.

But juniors don't just benefit from seniors. They benefit seniors. Mentoring forces you to formalize what you know. If you can't explain a concept to a junior, maybe you don't understand it as well as you thought. A junior's "why do we do it this way?" is a stress test on decisions that may just be inertia. Seniors who never mentor can plateau without noticing. And mentoring is the first step toward leadership. Without juniors, you never find out which seniors could become engineering managers.

In my experience, a prolonged absence of juniors correlates with a quiet stagnation. Not a universal law. But a pattern I see repeatedly.

The market confirms the trend. Employment for 22-25 year-old developers has dropped 20% since 2022. In France, IT employment for under-30s fell 7.4% in a single year. Apprenticeship subsidies have been cut. And every company that freezes junior hiring is right for itself. The problem is collective. No juniors today, no mid-levels in 5 years, no seniors in 10. Who reviews AI-generated code in 2031?

Mentoring remains the foundation. It needs to evolve.

At Jolimoi, we didn't have the budget to hire seniors. So we hired juniors. And we trained them.

The mentoring was structured. Half a day per sprint, a detailed training plan from the start, feedback at the end of each cycle. I chose these juniors carefully. Some stayed a long time. I brought several of them up to senior level. And those seniors mentored the next wave. The system fed itself.

Then the first external seniors arrived. They were better than me on many subjects, and that unlocked the team at a level I couldn't have reached alone.

All of this was before AI. The structure of mentoring (plan, rhythm, feedback, handoff) remains valid. The content needs to evolve.

Three years ago, we trained juniors to code, debug, structure. Today, there's an additional layer: when to use AI and when to code yourself. Developing judgment WITH the tool, instead of losing it because of the tool. Recognizing that generated code compiles but doesn't hold. That discernment doesn't come from prompting. It comes from being accompanied by someone who has it.

Nobody has the complete playbook yet.

Shopify structured its hiring in 3 parts: no AI, AI optional, AI mandatory. The same logic could be applied to mentoring. Microsoft proposes a "preceptor program" where mentoring becomes an explicit organizational goal, not a byproduct of daily work.

On the learning side, a few practices are taking shape. Code first, compare with AI output after: comparison builds judgment, the reverse builds nothing. Use AI to review your own code rather than to write it. Ask AI to explain why, not to give the answer. Some teams go as far as a no-AI day per week, to force the fundamentals. None of this is proven at scale yet. In every team where I discuss it, the intuition converges: preserve the cognitive effort.

I don't know yet what mentoring will look like in 2 years. Leaving juniors alone with AI doesn't build engineers. Human mentoring remains the foundation, and AI makes its absence even more costly.

So what ?

We talk a lot about what AI will replace. Not enough about what it can't build: judgment, doubt, the instinct that code compiles but won't hold, that a spec looks clean but doesn't solve the right problem. You can't prompt that. You transmit it.

While most companies are cutting junior positions, Shopify is doing the opposite: scaling from 100 to 1,000+ interns per year. Their bet: juniors who grew up with AI bring a perspective that seniors trained before AI don't have. As Farhan Thawar puts it: "These folks coming out of schools now are AI native. We wanted to bring those types of people in to reimagine what it looks like to build."

The real question isn't "do we still need juniors?" It's "do we still know how to train them?"

And the first answer might be the simplest: let’s start hiring junior again.

Sources

(1) Anthropic, How AI assistance impacts the formation of coding skills
(2) MIT Media Lab, Your Brain on ChatGPT: Accumulation of Cognitive Debt