The senior developer shortage is coming. We're engineering it ourselves.

Every company cutting junior hires right now is making the same calculation. One senior developer with Cursor or Claude Code ships what used to take three people. GitHub Copilot costs $19/month. A junior costs $85k/year, plus six months of mentorship before they're net positive. The CFO does the math in a spreadsheet. The spreadsheet is right.

The pipeline nobody is watching

Here's how senior developers get made. It doesn't happen in a bootcamp. It doesn't happen reading docs. It happens over five to seven years of being wrong in small, survivable ways — shipping a bug that wakes you up at 2am, getting your PR torn apart by someone better than you, inheriting a codebase that six engineers built before you and having to make it do something none of them planned for.

That process requires junior developers to exist in the first place.

These aren't isolated decisions. They're the same decision, made by thousands of companies simultaneously, driven by the same AI productivity story.

The five-to-seven year mentorship lag means the damage won't show up on any quarterly metric until it's already irreversible. The CEOs making these calls won't be in the same chair when the bill comes due.

The AI-review burden nobody talks about

Companies cut junior developers partly to remove the mentorship burden from seniors. What they replaced it with is worse.

Without juniors to delegate to, senior engineers now review AI-generated code instead. The volume is higher. The quality floor is lower. And unlike a junior developer, the AI doesn't level up. You're reviewing the same class of mistakes in perpetuity — hallucinated function calls, missing edge cases, logic that passes CI and fails in production three weeks later. At least a junior who shipped that bug learned from it. The sandbox doesn't.

When there's nobody asking why — when the only code review happening is a senior checking AI output against their own expectations — the architectural debt accretes silently. Nobody asks the AI why it made a structural choice. The AI doesn't know.

We've seen this before

This is not unprecedented. It just happened somewhere else first.

At that point, every company that ran the spreadsheet will be competing in a talent war for a pool they all collectively drained. Senior developer salaries will spike. Offer acceptance rates will collapse. Time-to-hire will stretch to months. The $85k you didn't spend on a junior will cost you $200k in a bidding war for someone with three years of experience.

The thing AI can't manufacture

There's a version of this essay that ends with "so AI will solve the experience problem too" and some claim about how AI mentorship will replace human mentorship within five years.

Maybe. But right now that's not what's happening. What's happening is that 22-year-olds who should be getting their first production scars are instead getting 7.5% unemployment. What's happening is that senior engineers who should be growing the next tier of their teams are instead alone with Cursor in a 1:1 relationship with generated code, gradually losing the interpersonal transmission belt that the industry runs on.

It's the instinct to read a PR and notice that something is off before you can articulate why. It's knowing which parts of a system to be scared of. None of that compounds without someone to carry it across to.

It's rational at the company level and catastrophic at the system level. Every company doing it individually is making the sensible local decision and collectively making the worst industry decision since the dot-com buildout.

What the firms getting this right look like

Not every company is making the same bet. The ones building durable engineering orgs in 2026 are doing something that looks counterintuitive from a spreadsheet: they're maintaining junior hiring, but redesigning what junior work looks like.

The old model was: hire junior, give them tickets, hope they absorb culture through osmosis. That model was already bad before AI. The new model pairs junior developers directly with AI-augmented workflows — but keeps the human mentorship layer intact. Juniors aren't writing boilerplate anymore, which is fine, because that was never the point. The point was learning to debug, to reason about systems, to develop the judgment that becomes senior instinct. That process still needs humans, just structured differently.

The actual risk calculation

If you are a CTO or engineering lead making hiring decisions right now, here is what you are actually betting on when you cut junior headcount:

That is not a conservative bet. That is an optimistic bet on market conditions nobody has any reason to expect to hold.