AI Killed the Junior Dev. The Senior Dev Pipeline Just Broke.

A Stanford Digital Economy study found that employment for software developers aged 22-25 has fallen nearly 20% since its peak in late 2022. For AI-exposed IT and software roles specifically, employment for that cohort is down 6% while it's up 9% for developers aged 35-49.

The headline is that AI is displacing junior developers. That's accurate. But the more important story is downstream: the training pipeline for senior engineers just broke.

How senior developers used to be made

The conventional path was: join a team as a junior, do the boring work — small bugs, well-defined tickets, code reviews on trivial PRs — and accumulate, over several years, a model of how real systems behave under real conditions.

The boring work was the pedagogy. Writing a bugfix in a million-line codebase teaches you things no course teaches: where the state actually lives, which abstractions are lies, which modules are quietly doing ten things their names don't suggest. You build a consequence model for real systems by suffering the consequences of not having one.

That's what junior roles were for. Not the output — the learning.

What's being cut

Stack Overflow's data shows that 70% of hiring managers now believe AI can do the jobs of interns. Internships across all industries declined 11% year-over-year; tech-specific internship postings fell 30% since 2023. Hiring managers trust AI output more than they trust new graduate output.

This is economically rational in the short term. AI does produce more consistent output on well-defined tasks than a developer who graduated six months ago and is still building their mental model of the codebase. The immediate return on a junior hire has always been low — the value was in the person they'd become in three years.

When you eliminate the junior role, you're not making the team more efficient. You're canceling the three-year investment that would have produced your next senior engineer.

The judgment can't be transferred directly

I started programming at 12. I had three years of professional experience before I took on a tech lead role coordinating a larger development project. That tech lead position was the hardest thing I'd done — not because the technical problems were novel, but because navigating the coordination overhead and making decisions I could defend required a model of how systems and teams fail that I'd built by making smaller mistakes first.

No amount of prompt engineering or code review of AI output reproduces that. The learning that matters happens when you make the wrong call, watch the consequence unfold, and update your model. That requires actually making calls. It requires being in situations where your judgment determines what happens next.

Junior developers in entry-level roles are in exactly those situations. On contained problems. With enough structure that the failures are survivable. This is the pedagogically correct design.

What's replacing it? Senior developers reviewing AI output. That's not a training environment. That's quality assurance.

Who notices this first

The cohort entering the industry now will arrive at their mid-30s without the base of experience that current 35-49 year olds accumulated as juniors in the years before AI. The judgment gap won't be visible for a decade. It will appear as a generation of developers who are fast at generating code and systematically weak at the tradeoff judgment that comes from having made many mistakes at scale.

The current data shows the cohort split: young developers losing work while experienced ones gain ground. This makes sense today. What happens when the experienced cohort retires and the middle-experience cohort — the ones who spent their formative years reviewing AI output rather than debugging their own failures — inherits the systems?

I don't know. Nobody does. But eliminating the junior pipeline and assuming the experience gap will close itself is an assumption being made implicitly, at scale, right now.

This is a design problem

The solution isn't to keep hiring juniors for the sake of it. The solution is to recognize that AI tools change what junior developers should be learning, not whether they should exist.

Junior roles structured around doing what AI can now do faster — boilerplate, well-defined tickets, syntax-level tasks — are correctly being cut. But there's a version of the junior role that explicitly trains judgment: designing small systems under constraints, debugging failures in production with supervision, making tradeoff decisions and reviewing the consequences. That role doesn't require low-value output. It requires intentionally structured exposure to consequential decisions.

The teams that figure this out will have senior engineers in ten years. The teams that cut all junior roles and assume AI fills the gap will have a workforce that is extremely fast at generating code that nobody fully understands.

That's not a productivity win. It's a slow structural failure, accumulating now.