Everyone Wants Senior Engineers. Nobody Wants to Make One.

Walk into almost any engineering team right now and there's a quiet conversation going on, the kind nobody says out loud. "Why hire a junior? One senior with an AI assistant ships the same work in half the time, and we don't have to babysit anyone." Fair enough. Give it ten years, though, and it's one of the most destructive ideas in the industry.

Think about it. If AI does the junior work, nobody hires juniors. Nobody hires juniors, nobody trains them. So where are the senior engineers of 2035 supposed to come from?

AI killed the entry-level job

For decades, the entry-level job existed for a simple reason: somebody had to do the boring work. The boilerplate, the simple CRUD screens, the first-draft tests, the small tickets no senior wanted to touch. Not glamorous, but real work that paid, and cheap enough to hand to someone who didn't know much yet.

That's the work AI is best at. One senior with a decent AI tool now clears the simple tickets, scaffolds the boilerplate and drafts the tests in an afternoon, work that used to keep two or three juniors busy. So the maths does itself: why pay, onboard and babysit a fresh grad to do work a model does in seconds and never asks for a raise?

Look at one quarter at a time and it's airtight. A junior was always a slow, expensive, risky bet that only paid off years later, if they didn't leave first. AI is fast, cheap and here today. So every hiring manager who picks "senior plus AI" over "hire and grow a junior" is making a call you can't really argue with. That's what makes it so dangerous. Nobody has to be wrong for the whole thing to break.

But the junior work was the apprenticeship

But the spreadsheet misses something. Those boring junior tasks were never just output. They were the training ground.

You don't become a senior engineer from a course or a book. You get there by doing ten thousand small, slightly-too-hard things until you build a feel for which ones matter. Fixing the bug. Breaking production and figuring out why. Getting your pull request torn apart. Watching a "clever" shortcut turn into a 2am outage. The junior years were a long apprenticeship dressed up as a job, and the grind was the whole point.

We've made this argument about individuals before: that vibe coding lets people ship software they don't understand, and that AI is a multiplier of skill, not a substitute for it. The pipeline crisis is the same disease at the scale of an entire profession. Multiply a shallow engineer by ten and you still have a shallow engineer. You've just lost the slow, expensive process that would have made them deep.

Now seniors mentor a machine, not a person

And there's a second refusal sitting on top of the hiring one: most seniors don't really want to train juniors anyway. Mentoring is invisible, unpaid, and usually punished. Spend three hours a day unblocking a junior and you ship less of your own work, your velocity drops, and come review time the question is "what did you ship?", never "who did you grow?"

AI just handed those seniors a guilt-free way out. Why explain the same concept to a nervous grad for the third time when the model answers instantly, never sulks, and doesn't post "promoted, now leaving" on LinkedIn eighteen months later? The senior's day-to-day "apprentice" is an AI now. Great tool. But it learns nothing it can pass on, it mentors nobody, and it's never going to become the next senior.

Where do you think seniors come from?

This is the question the whole industry is pretending not to hear. A senior engineer isn't a job category you can just post for. They're the end result of a long process: years of messy, expensive, low-return investment, with someone more experienced soaking up the damage from every mistake. Every senior you're desperate to hire today survived the exact apprenticeship that AI has now made pointless.

So when every company decides to skip the junior, rent a ready-made senior and let AI handle the grunt work, they're all drinking from the same well of senior talent and nobody's putting any water back. It works fine right up until the well runs dry. And a well doesn't drain in a way that scares you. It looks full for years, then one day it's empty.

We've written about adjacent versions of this: how more programmers don't make a project faster, and how code got cheap but software didn't. The throughline is always the same. The scarce thing was never typing. It was judgement, and AI just automated away the only known method of growing it.

The irony that should terrify the industry

There's a twist that makes this more than a labour-market story. AI, the thing that killed off the junior, is itself useless without seniors.

An AI coding tool is a multiplier. It speeds up someone who already knows what good looks like, who can spot the quiet bug in generated code, who knows which 10% of the output matters and which 90% is convincing nonsense. Hand the same tool to someone with no judgement and it cheerfully helps them build the wrong thing faster. So AI doesn't lower the need for senior judgement. It raises it, because now there's ten times more code to check and a machine that's wrong in very believable ways.

So we've built a machine that (a) needs senior engineers to be used safely, and (b) is busy tearing down the only pipeline that makes senior engineers. We're burning through the seniors we already have to run AI, while AI quietly makes sure fewer of them ever get made. That's not a productivity boom. That's eating your seed corn and calling it a harvest.

The math of a pipeline that stops refilling

Demographics are boring and they don't care about your feelings. Engineers retire, move into management, switch careers, or burn out. Call it a few percent of the senior pool walking out the door every year. In a healthy industry, those people get replaced from below: juniors get hired, trained, and grow into seniors over five to eight years. The pyramid stays standing because the base is wide.

Saw off the base, let AI swallow the entry-level work and stop hiring at the bottom, and the pyramid doesn't fall over tomorrow. It falls over on a delay. For the first few years nothing looks wrong. You still have all your seniors, AI made them faster, and you saved a pile of money skipping the juniors. Then the seniors start leaving at the usual rate, and for the first time there's nobody behind them. Now the pyramid is balancing on its tip. That's where the industry is heading right now, one sensible AI-assisted hiring decision at a time.

What this actually costs, and who pays

The fresh grads pay first, and most obviously. A whole generation of capable, eager people gets told the bottom rung doesn't exist anymore. The work they'd have learned on is done by a model, and the only experience anyone will accept is "more than they could possibly have yet." Plenty of them leave the profession before they even start.

But the companies pay too, just later. The senior you didn't grow today is the senior you can't find or afford in 2035. Pay for deep expertise will keep climbing, not because the work got harder, but because AI quietly turned the supply into a shortage. Software quality drops across the board as more of it gets built by people who never had a senior to learn from, supervising AI they're not equipped to question. The field gets shallower right when the systems it builds get more important.

And the cruel part: by the time the shortage is obvious enough that everyone acts on it, the fix already takes a decade. You can't microwave a senior engineer, and you definitely can't prompt one into existence. The only way to have one in 2035 is to start growing them now. The cheapest time to fix this was years ago. The next cheapest time is today.

So what does a sane company actually do?

None of this is an argument against AI, and it's definitely not a plea to hire juniors out of charity. The point is simpler: while everyone else uses AI to delete the junior, the companies that use AI to speed the junior up will be the only ones with real engineers in ten years. That's not sentiment. That's an edge.

This is the model we run at Heartbyte, and not for warm-and-fuzzy reasons. We use AI heavily and we grow our engineers on purpose, because deep senior judgement is what lets us aim AI at the right problem and catch it when it's confidently wrong. You can't buy that pipeline off the shelf once it's dried up. You can only have built one while everyone else let a model do the teaching.

The honest version

Nobody set out to break the engineering talent pipeline, and that's what makes it dangerous. It's the sum of a thousand reasonable, AI-assisted choices. Let the model do the junior work. Skip the junior hire. Let the senior coach a chatbot instead of a person. Each one makes perfect sense for one company in one quarter, and together they quietly dismantle the machine that makes the very people everyone, AI included, depends on.

Everyone wants a senior engineer. AI just made it easier than ever to dodge the slow, expensive, unglamorous work of making one. That's not a stable setup. It's a countdown, and the clock started the day we decided the model could do the learning for us.