How the "Junior -> Senior" dev problem will be solved

How will we train senior developers in a world where there is no more work for junior or mid-level developers?

Because, if there is no room for junior developers, then no one will become a mid-level developer, and then no one will be able to progress to senior developer, and then the world will run out of that precious resource and...

Let's unpack this nonsense.

The current state of things

A whole lot of people in tech seem blissfully oblivious to the fact that tools like Claude Code with Opus 4.5 basically make junior and mid level developers entirely unnecessary.

Most of these people are likely to themselves become entirely obsolete, at least as far as demand for their development work goes. See, the core skill of software engineering isn't "typing code". It's not even "conceiving and writing working code". It's not "designing and building working software" either.

The core skill of a software engineer is learning.

This is because every project requires, and usually uses, a slightly different tech stack, so we always have to learn new things as part of our day to day work. And that tech stack evolves. New things get added, old things get removed or replaced... It's a never ending process of learning new technologies, libraries, frameworks, project idiosyncrasies, etc.

People who, in late 2025, still haven't bothered to get off their comfy "I'm a senior dev in environment X" armchair and start learning how to use the AI coding tools that are transforming our field, and people who have "given them a try" and then dismissed them as "just a fad" or "overhyped" or "not that useful, I tried doing X and it failed", are displaying a colossal failure of those most basic ingredients of learning: curiosity, excitement at discovering something new, eagerness to figure out how to build something with the new toy.

They're a bit like a painter who has been spending 8 hours a day making their own paints from scratch, hears about a process that means paints can be made en masse so that painters can focus on painting, and shrugs and carries on with their process, saying the shade of one of the phtalo blues from one manufaturer is slightly off so "it's just a fad" and will blow over. Sure, they can continue painting, probably, and in a field like art they may still be successful, but they've clearly marked themselves as dinosaurs.

For those who aren't unaware of the incoming tsunami, though, and how it completely obviates the need to ever hire junior or mid-level developers, there is a genuine worry about "how do we get seniors if we tear up the junior and mid-level pipeline?"

The pipeline of mediocrity and the speed ramp of excellence

I've been making software for over 3 decades. My very first "successful" blog post, all the way back in 2007, was titled "How to recognise a good programmer?" In it, I asserted that "good programmers" enjoyed programming outside of work or university as well.

Some agreed with me, some disagreed and called me a moron who didn't know anything about software engineering. That blog post got a lot of people worked up.

Nearly two decades later, though, I think my prior insight is more correct than ever.

There are two paths to becoming a "senior" developer. One is the path most people take:

1. Do a CS or related degree.
2. Get a job as a "junior software engineer" somewhere.
3. Stick to it, work hard and accrue experience.
4. Get promoted up the ranks, until you're a "senior software engineer" of some sort.

This is the path I like to call the "conveyor belt", and I don't believe it results in good developers, senior or otherwise. Sure, there are exceptions, but in general, I think people who follow that pipeline tend to fail at the core skill of the software engineer, explained earlier: learning, curiosity, excitement at the new, desire to build new things with the latest tech.

What AI is doing is it's slamming the brakes on the conveyor belt path. Previously, the only way to expand a dev team's capacity was to hire more people. Rapidly, this is becoming a slow, bloated and expensive solution, and the better alternative is: spend more on tokens. It's a lot cheaper than hiring people, a lot less hassle, it doesn't impact your nimbleness nearly as much, and it's getting better every month, unlike most junior devs who need much longer timelines to improve. The case for hiring juniors and even mid-level devs, at this point, is nil.

But there is another path. It turns out, you don't need anyone to teach you software engineering. Or rather, you don't need anyone to teach it to you formally. Because there are millions of ways to self-teach.

When I was learning to program, I had to take the bus to the centre of Geneva to hang out in the one IT bookstore that actually had a good selection of computing books (thanks for the early unintended sponsorship, Ellipse!), and sit in the store reading the books because I often couldn't afford them, and then go back home and try to apply what I'd learned.

Today, there are so many free or near-free resources to learn how to program, all over the internet, that anyone who wants to learn basically anything, can access the teachings instantly from anywhere. Even better, LLMs themselves make great coaches and teachers and can accelerate that learning even more.

Let's call this the "bootstrap path". This path is still open. Anyone can learn. Anyone can then apply that knowledge and build things and deploy them and then build new thing and see what happens. And so if they're passionate about building software, anyone can carve their way from wherever they are, to a senior level of knowledge and experience, just by doing things.

You can just do things.

The conveyor belt path, where someone else will spoon-feed juniors the things they need to learn to go up the skills ladder, is over. But the bootstrap path is wide open and better than ever.

So the question of "how will we train senior software engineers?" is a dead end.

We will not train senior software engineers.

They will train themselves, or they will do something else. The era of offering formal training and career support and progression to "software engineers" who don't have the drive to train themselves, is over.

I suspect this will greatly increase the quality of "senior software engineers", especially when combined with the Great Filtering of all the software engineers who managed to be unexcited about the most transformative thing to happen to software engineering ever (AI, I mean).