The training ladder is broken. And nobody has a plan to fix it

Entry-level developer hiring has dropped 67% since 2022. At the fifteen largest US tech companies, new graduate hiring has fallen by more than half since 2019. Fresh graduates now make up just 7% of big tech hires. At startups, the number has gone from 30% to under 6%.

These aren't projections. These are the numbers right now.

And almost nobody in a leadership position is talking about what happens next.

The logic that got us here

The reasoning is straightforward, and on the surface, hard to argue with.

AI tools can now do a significant portion of what junior developers used to do. Bug fixes. Boilerplate code. Test writing. Documentation. Simple feature implementation. The tasks that used to take a new graduate three days now take an AI agent three minutes.

So companies look at the numbers and make the obvious call: why hire a junior at £60-90K when an AI tool costs a fraction of that? Hire fewer, more experienced engineers. Give them agentic AI tools. Get more output from a smaller, senior team.

I understand the logic. I've been in the room when this decision gets made. And in the short term, it works. Headcount drops. Output holds. The CFO is happy.

The problem is that this logic has a time bomb buried in it.

Where senior engineers come from

This might seem obvious, but it needs saying: every senior engineer was once a junior engineer.

The skills that make someone a valuable senior developer (architectural judgement, debugging intuition, the ability to read a codebase and understand not just what it does but why it was built that way, the instinct for where a system will break under load) none of these come from courses or certifications. They come from years of doing the work. The grunt work. The work we're now automating away.

Harvard economists analysed 62 million LinkedIn profiles and 200 million job postings. Their finding was precise: at firms that adopted generative AI, junior headcount fell 7.7% within six quarters. Senior employment barely moved. The decline was steepest among graduates of mid-tier universities, not the elite schools (those graduates are too productive to replace) and not the lowest tier (too cheap to bother replacing). The middle got squeezed.

Mark Russinovich, Azure's CTO and not exactly a junior voice in this conversation, published a paper in February with Scott Hanselman arguing that AI tools "give senior engineers an AI boost while imposing an AI drag on early-in-career developers." He said this is now a hot topic in every customer engagement Microsoft has. Every company sees it. Nobody has a plan.

Matt Garman, the CEO of AWS, was more blunt. He called replacing junior developers with AI "one of the dumbest things I've ever heard." His reasoning: juniors are the least expensive employees you have, and they're the most engaged with AI tools. Cut them, and in ten years "you have no one that has learned anything."

The training ladder problem

Software engineering has always had an informal training ladder. You join as a junior. You fix bugs. You write tests. You struggle with a codebase someone else built. You make mistakes and learn from the code review. You pair with a senior who shows you why your elegant solution won't survive production traffic. Gradually, painfully, you develop judgement.

That ladder is being dismantled. Not deliberately. Nobody set out to destroy it. But the economic incentives are all pointed the same way: automate the junior work, hire fewer juniors, give the savings back to the business.

The problem is that the junior work was the training. It wasn't grunt work that happened to be done by beginners. It was the mechanism by which beginners became experts.

Anthropic, the company that builds Claude, ran their own study on this. Junior engineers using AI scored 50% on comprehension tests. Those who coded manually scored 67%. The largest gap appeared in debugging, the exact skill that separates a competent senior from a dangerous one.

Stack Overflow's monthly question volume has collapsed from 200,000 at peak to under 4,000 by the end of 2025. That's a 78% year-over-year decline. The knowledge ecosystem that trained a generation of developers, and that AI models themselves were trained on, is dying.

The five-year cliff

Octopus Deploy's AI Pulse Report projects a three-phase crisis: experimentation (2024-2025), junior hiring freeze (2025-2027), and senior talent crisis (2027-2030).

I think that timeline is roughly right. The wage gap is already widening. US junior developers earn $75-95K while seniors command $193-263K. That gap will widen further as junior supply increases (more graduates, fewer positions) and senior demand intensifies (fewer juniors maturing into senior roles, more AI systems requiring senior oversight).

The maths is simple. If you stop feeding the bottom of the pipeline, the top of the pipeline runs dry. Not immediately. Not this quarter. But the organisations making these cuts today will feel the consequences, and by the time they feel them, rebuilding the pipeline will take years, not months.

What I'd actually do about it

I don't think the answer is to ignore AI's capabilities and keep hiring juniors to do work that AI genuinely does better. That's nostalgic, not strategic.

But I do think the answer requires more imagination than most organisations are applying. Here's what I'd recommend to any CTO or engineering leader thinking about this:

Redefine what juniors do, don't eliminate the role. The junior developer role needs to evolve, not disappear. Instead of writing boilerplate, juniors should be reviewing AI-generated code, learning to spot the patterns of failure that AI produces (and it produces them reliably; CodeRabbit's data shows AI creates 1.7x more bugs and 2.74x more security vulnerabilities than humans). This is a different training ground, but it's still a training ground.

Make mentorship a measured responsibility. Russinovich and Hanselman's paper proposes a "preceptor model," structured mentorship where senior engineers are explicitly assessed on developing junior talent. I'd go further: make it a promotion criterion. If you can't develop the people around you, you're not senior. You're just experienced.

Invest in the AI-native training path. Shopify is hiring 1,000 interns specifically for what they call "AI-native thinking." That's a bet on a new kind of training ladder, one where the junior's job is to direct AI agents, evaluate their output, and develop the judgement to know when the output is wrong. It's a different skill set, but it still requires deliberate development.

Budget for the future, not just the quarter. The short-term savings from cutting junior hires are real. The long-term cost of having no pipeline is also real, and much larger. The organisations that get this right will be the ones that treat junior development as an investment with a 3-5 year payback period, not a cost to be optimised away.

The uncomfortable truth

I've built engineering teams. I've hired juniors who became the best engineers I've ever worked with. And I've watched what happens when organisations optimise purely for short-term efficiency at the expense of long-term capability.

The uncomfortable truth is that the market is telling companies to do something that is locally rational and globally catastrophic. Cut the juniors. Save the money. Ship more with fewer people. And then, in five years, wonder why there are no senior engineers available, and why the ones who exist command salaries that make the original savings look like pocket change.

The companies that will have the strongest engineering teams in 2030 are the ones making the unfashionable decision to invest in junior talent today. Not because it's charitable. Because it's strategic.

If you're rethinking your engineering team structure and want to talk through the trade-offs, get in touch.