AI didn't kill your junior pipeline. You did

Last week someone posted a job listing in a public engineering Slack community. "Junior Developer, Remote, Python/Django." Pretty standard stuff. The kind of listing that, three years ago, would have attracted a pile of applications and maybe a few "great opportunity!" replies from people trying to be helpful.

The first reply was "lol, companies still hire juniors?"

The second was "just use Claude bro."

The third was just:

That last one got forty-seven laughing reactions. The person who posted the listing deleted it twenty minutes later.

I stared at that thread for a while. Not because any individual reply was remarkable (Slack communities have been casually cruel since Slack communities existed) but because of what it represented. Somewhere in the last eighteen months, the engineering industry collectively decided that an entire tier of the profession was obsolete. Not through research. Not through careful analysis of what the talent pipeline actually needs. Through vibes. Through memes. Through VPs who went to a conference and came back saying "AI does junior work now" like they'd just discovered fire.

Or, more accurately, like they'd just discovered a vendor booth with good coffee and a very confident sales deck.

I scrolled back through the thread later. The person who posted the listing had been trying to hire for three weeks. Good company, decent salary, remote-friendly. They'd posted it because they actually believed (correctly, as it happens) that bringing in a junior and investing in their growth was better long-term strategy than fighting over the same twelve senior engineers as everyone else.

And the community laughed them off the platform.

That's where we are. The people making the right call are being mocked by the people making the short-sighted one. And nobody stopped to ask the obvious question: if nobody hires juniors, where the fuck do seniors come from?

The ladder

Every senior engineer reading this got their start somewhere. An internship. A graduate programme. A first job where they were in over their head and someone more experienced took the time to show them how things actually worked. Maybe it was a patient tech lead who pair-programmed with them on a Friday afternoon. Maybe it was a grumpy staff engineer who tore their PR apart and, in doing so, taught them more about software design than any course ever could.

That path, junior to mid to senior, isn't just a career ladder. It's the mechanism by which the industry reproduces its own expertise. It's how knowledge transfers.

It's how the next generation of engineers develops the judgement and taste that separates code that works from code that matters.

And we're dismantling it. Cheerfully. With LinkedIn posts about "efficiency."

Every senior engineer alive today got their start doing the exact grunt work they're now saying juniors don't need to do. That's not progress. That's pulling the ladder up behind you.

I want to pause here because this is the part that genuinely bothers me and I don't want to bury it in a joke.

There are people right now, thousands of them, who spent years learning to code. They went to university, or they went to bootcamps, or they taught themselves at night after working their day job. They did everything the industry told them to do. And they're being told, by the very people who benefited from the path they're trying to walk, that the path no longer exists.

That's 22-year-old with tens of thousands of dollars in debt staring at a job market that's decided they're obsolete before they've even started. And the people making that decision got their own start writing the exact kind of code they now claim a machine can handle.

I don't know what to call that, but I know it's not something to celebrate with a laughing emoji in a Slack thread.

The maths nobody wants to do

Senior engineers don't appear from thin air. There is no artisanal senior engineer micro-brewery in the hills outside Palo Alto, no matter what your recruiter’s LinkedIn posts imply. You can't even order them on Amazon Prime, although I'm sure someone in procurement has tried.

Senior engineers are what you get when you hire a junior, give them interesting problems, surround them with people who know more than they do, and wait. That's it.

Every senior engineer in your organisation was, at some point, a junior who didn't know what a database index was. Every staff engineer who's now making critical architecture decisions once shipped a PR that made a senior's eye twitch. Every principal engineer who can hold your entire system in their head once accidentally dropped a production table and learned a lesson they never forgot.

You're not saving money by cutting junior hiring. You're borrowing seniors from a pool that the entire industry has collectively decided to stop replenishing.

Right now, every company is fishing from the same pond of experienced engineers. Nobody is restocking the pond. Do the maths on where that goes. In three years you don't have enough mid-levels. In five years you're in a bidding war for seniors that makes the 2021 hiring market look quaint. In seven years you're hiring "senior engineers" with three years of experience because that's all that's left, and you're pretending that's fine.

It's not fine. You just haven't felt it yet because there's still a generation of engineers in the pipeline who were hired before the doors closed. When that generation ages and nobody's behind them, the cliff is going to be spectacular. But by then the people who made the decision will have moved on to their next role, which is how most short-sighted org decisions survive: the people who made them aren't around for the consequences.

You didn't build a leaner org. You built a brittle one.

I was on a call last month with a CTO who was genuinely proud of his team structure. Twelve senior engineers, zero juniors, everyone paired with AI tools. "We're running at 3x the output of a team twice our size," he told me, with the kind of confidence that usually precedes a disaster.

I asked him what happens when three of those seniors leave.

Long pause.

"That won't happen."

This is the same category of sentence as “we don’t need backups” and “the migration should be straightforward.”

It will happen. It always happens. People leave. They get poached, they burn out, they move countries, they decide they want to build furniture or milk goats instead of write software. That's not a risk factor. That's Tuesday. And when it happens to his team, he's going to discover something uncomfortable: there's nobody in the pipeline, there's nobody on the market (because everyone else cut their pipeline too), and the AI can't onboard itself.

A team of seniors plus AI looks like a restaurant staffed entirely by head chefs. Brilliant food, for a while. Then someone has to prep onions, wash pans, train the next cook, and notice the fridge is open.

The thing about juniors that nobody values until they're gone isn't just their future potential. It's the redundancy they create. It's the fact that someone is always learning the system from scratch, which means someone always has recent context on how the onboarding works (or doesn't), where the documentation gaps are, and which parts of the codebase are held together with wishful thinking and a comment that says // TODO: fix this properly.

When your entire team is senior, everyone assumes everyone else understands everything. Nobody asks the basic questions. Nobody maps the undocumented tribal knowledge. And when someone leaves, a chunk of that knowledge walks out the door with them and you discover just how much of your "lean" org was actually one resignation away from a crisis.

You killed curiosity and replaced it with autocomplete

Here's something that happened on literally every team I've ever managed that had juniors: the junior asked a question that made a senior realise something was broken.

"Why do we do it this way?"

"Why does this service call that service instead of going directly?"

"This error message says 'contact support' but there's no support page. What's supposed to happen here?"

These aren't sophisticated questions. They're better than that. They're the questions that nobody who's been around for two years thinks to ask anymore because they've gone nose-blind to the smell. Juniors are your canary in the coal mine. They see your system with fresh eyes and they haven't yet learned which problems they're supposed to ignore.

You didn't just cut a role. You cut the only people in your organisation who were still asking "why?" instead of "how?"

One of the best production incidents I ever witnessed (and I use "best" the same way you'd describe a really educational car crash) was caught by a junior who asked why a config value was hardcoded. "It's always been that way," said the senior. The junior, not yet trained in the art of accepting terrible answers, kept pulling the thread. Turned out the hardcoded value was a database connection limit from 2019 that nobody had updated when they moved to a cluster that could handle 10x the connections. They'd been running at one-tenth capacity for two years. Two years. Because everyone senior enough to fix it was also senior enough to have stopped seeing it.

You can't prompt your way to that kind of discovery. AI doesn't ask "why?" It does what you tell it.

Which is great, provided what you told it wasn’t fucking stupid, totally incomplete, politically convenient, or just straight copied from a ticket written by someone who has since left the company. Which never happens, right?

There's a subtler version of this too. Juniors don't just ask questions about the code. They ask questions about the process. "Why do we deploy on Tuesdays?" "Why does this ticket need sign-off from three people?" "Why are we building this feature when nobody uses the last one we shipped?" These are the questions that make senior engineers and managers uncomfortable, because the honest answer is often "I don't know, that's just how we've always done it." And sometimes that discomfort is the exact thing that triggers a change nobody else was willing to push for.

Remove the juniors and you remove the irritant. Sounds nice until you realise that irritant was the only thing stopping your processes from calcifying into rituals that nobody questions and everybody resents.

Your seniors are atrophying too

This is the argument that widens the blast radius, and it's the one I almost didn't include because it's going to piss off the people I'm trying to help. But here it is.

Your seniors are getting worse. Every time they skip the hard thinking and prompt instead, they lose a little bit of the muscle that made them senior in the first place.

I'm not talking about using AI to generate boilerplate. That's fine, that's like using a calculator. I'm talking about the senior who used to spend an afternoon reasoning through a complex data model and now asks Claude to draft it, skims the output, and ships it. They got a faster answer. They also skipped the part where their brain did the work that made them capable of evaluating the answer in the first place.

I watched this happen on a team I was advising last year. Their most experienced backend engineer started routing every design decision through an AI tool. Three months in, the EM noticed something: his design docs had gotten thinner. Not because the problems were simpler. Because he'd stopped doing the deep thinking that used to produce the thick ones. He was editing AI output instead of generating his own ideas, and the gap between those two activities is where engineering judgement lives.

He didn't notice. Atrophy doesn't announce itself. You don't wake up one morning and think "I've forgotten how to design a system." You just gradually get more comfortable accepting the first answer instead of pushing for the right one. The muscle weakens so slowly that you mistake the weakness for efficiency.

You're not just killing the pipeline below. You're hollowing out the people you have left and saying "This is fine".

And here's where it gets properly bleak. Think about what happens when you combine these two forces. From the bottom: no juniors entering the pipeline, so no new mid-levels, so no new seniors. From the top: existing seniors slowly losing the depth that made them senior. The pipeline is collapsing from both ends simultaneously.

It's a pincer movement on your own capability and you're paying for the privilege. The same tools you're using to justify cutting juniors are simultaneously eroding the seniors who are supposed to be the reason you don't need juniors. If someone designed this as a strategy to destroy an industry's ability to produce quality software, you'd call it diabolical. But nobody designed it. It's just what happens when you optimise for this quarter's headcount budget and don't think about next year's talent pool.

You outsourced your talent strategy to companies that don't know your name

Speaking of paying for the privilege: you've decided that AI tools can do the work that juniors used to do? Fine. Who makes those tools? How much do they cost? What happens when the pricing changes?

Right now you're building your entire talent strategy on top of a technology provided by a handful of companies who are all, without exception, burning through cash at a rate that makes their current pricing unsustainable. OpenAI, Anthropic, Google, pick your favourite. None of them have figured out the long-term economics yet. They're in the growth phase where everything is subsidised and everyone feels clever.

When the pricing triples (and it will) you'll have no juniors, degrading seniors, and no bargaining power. You outsourced your entire talent strategy to a company that doesn't know your name.

This isn't hypothetical. This is what happens to every industry that becomes dependent on a single category of vendor without a fallback plan. You lose optionality. Your costs become someone else's pricing decision. And the fallback, hiring and training your own people, takes years to rebuild once you've dismantled it.

I've lived through this exact pattern before, just with different technology. Remember when everyone moved to the cloud and shut down their on-prem infrastructure? The ones who kept some internal capability had options when AWS had its pricing "adjustments." The ones who went all-in had a very uncomfortable conversation with their CFO and exactly zero alternatives.

Talent pipelines work the same way. The companies that kept their junior pipelines running will be the ones with options when the economics shift. Everyone else will be scrambling to rebuild something that takes three to five years to produce results, while paying whatever the AI vendors decide to charge in the meantime. And the vendors will know they have you by the throat, because where else are you going to go? Back to the humans you stopped training half a decade ago?

What to do instead (the bit where I stop yelling)

Look, I know I've spent the last couple of thousand words being fairly aggressive about this. So let me be constructive, because shouting into the void without offering a direction is just McKinsey without the invoice.

Redefine what juniors do. Don't delete the role. The work has changed. I'm not arguing that it hasn't. Juniors in 2026 aren't going to spend their days writing CRUD endpoints. But they can review AI-generated output, learning to spot the subtle wrongness that only develops through exposure. They can be the human in the loop, building the judgement that will eventually make them the senior you desperately need. The role isn't obsolete. The job description is. Update the job description.

Pair juniors with AI, not instead of AI. A junior with Cursor or Claude isn't a redundant hire. They're a faster-learning one. The AI handles the boilerplate, the junior builds the understanding. They're learning at 2x speed because they can see patterns, ask the AI questions, and experiment without waiting for a senior to be free. That's a training accelerator, not a replacement. The companies that figure this out will be developing mid-levels in eighteen months instead of three years.

I've actually seen this work. A startup I advise hired two graduates last quarter and paired each of them with an AI coding tool and a senior mentor. The graduates aren't writing code from scratch. They're reviewing what the AI produces, flagging what smells wrong, and learning why it smells wrong from the senior sitting next to them. Six months in, both of them can spot an over-abstracted module faster than some mid-levels I've worked with. They're not learning slower because of AI. They're learning differently, and in some ways they're learning faster, because they're seeing ten times more code patterns than a traditional junior would in the same period.

Partner with bootcamps and universities differently. Not just as a hiring pipeline, but as a co-design partner. The curriculum hasn't caught up to the reality that "junior developer" in 2026 means something fundamentally different from what it meant in 2022. Help shape what it looks like. Sponsor capstone projects that involve working with AI tools on real problems. Build the relationship before you need the graduates, because by the time you're desperate it's three years too late.

The point

Go back to that Slack thread. Someone posted a job listing for a junior developer and the community laughed them out of the room. Twenty minutes and it was deleted. Think about what that says about where we are.

We've built an industry that treats its own supply chain as a joke. We've decided, collectively and casually, that the mechanism by which every single one of us learned our craft is no longer worth maintaining. Not because we did the analysis. Not because we thought through the consequences. Because a machine can write a for loop and someone made a meme about it.

The companies that will dominate the next decade of software aren't the ones with the most AI tools. They're the ones that kept investing in people while everyone else was busy automating them away. They'll have the seniors, the institutional knowledge, the depth of understanding that only comes from years of humans teaching other humans how to think about hard problems.

Everyone else will be staring at a dashboard full of AI-generated output, wondering why nobody on the team can explain what any of it does, trying to hire experience from a market that ran out of it years ago.

The junior you didn't hire today is the senior you can't find in five years. And by then, it's too late.

Start hiring. Start training. Start building the pipeline again.

Before the only thing left to laugh at is yourselves.