Everyone Wants Senior Engineers. Nobody Wants to Make One.

Here's the conversation happening in engineering teams everywhere right now, usually without anyone saying it out loud. "Why would we hire a junior? A senior with an AI assistant ships the same work in half the time, with none of the hand-holding." It's a reasonable observation. It's also, on a ten-year horizon, one of the most quietly destructive ideas in the industry.

Because if AI does the junior work, and so nobody hires juniors, and so nobody trains them — then where, exactly, do you think the senior engineers of 2035 are going to come from?

AI sawed off the bottom rung

For decades, the entry-level engineering job existed because somebody had to do the unglamorous work: the boilerplate, the simple CRUD screens, the first-draft tests, the small well-defined tickets nobody senior wanted. It wasn't prestigious, but it was real, billable work — and crucially, it was cheap enough to hand to someone who didn't know much yet.

That entire category of work is exactly what large language models are best at. A senior engineer with a good AI tool now clears the simple tickets, scaffolds the boilerplate, and drafts the tests in an afternoon — work that used to justify hiring two or three juniors. So the cold business logic writes itself: why pay, onboard, and babysit a fresh graduate to do work a model does instantly and never asks for a raise?

From inside a single quarter, this is airtight. The junior was always a slow, expensive, risky bet that paid off years later — if they didn't leave first. AI is fast, cheap, and available today. Every individual hiring manager who chooses "senior plus AI" over "hire and grow a junior" is making a defensible call. That's precisely why this is so dangerous: nobody has to be wrong for the whole thing to break.

But the junior work was the apprenticeship

Here's the part the spreadsheet doesn't capture. Those boring junior tasks were never just output. They were the training ground.

You don't become a senior engineer by attending a course or reading a book. You become one by doing ten thousand small, slightly-too-hard things and slowly building the instinct for which ones matter — fixing the bug, breaking production and learning why, getting your pull request torn apart, watching a "clever" shortcut become a 2am outage. The junior tier was a decade-long apprenticeship disguised as a job. The grind was the 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

There was always a second, quieter refusal sitting above the hiring decision: seniors don't really want to train juniors anyway. Mentoring is invisible, unpaid, and actively penalised — a senior who spends three hours a day unblocking a junior ships less of their own work, watches their own velocity drop, and at review time gets asked "what did you ship?" rather than "who did you grow?"

AI just handed those seniors the perfect, guilt-free exit. Why explain a concept to a nervous graduate for the third time when the model answers instantly, never gets discouraged, and doesn't put "promoted, now leaving" on LinkedIn eighteen months later? The senior's day-to-day "apprentice" is now an AI. It's a fantastic tool — and it learns nothing it can pass on, mentors no one, and will never become the next senior.

Where do you think seniors come from?

This is the question the whole industry is pretending not to understand. A senior engineer is not a hiring category you can simply post for. It is the output of a process — years of messy, expensive, low-ROI investment, with a more experienced person absorbing the blast radius of every mistake. Every senior you're desperate to hire is the survivor of exactly the apprenticeship that AI has now made redundant.

So when every company decides to skip the junior — to rent a finished senior and let AI cover the grunt work — they are all drinking from the same well of senior talent while refusing, on principle, to put any water back in. It works beautifully right up until the day the well is empty. And wells don't drain in a way that scares anyone. They look fine, fine, fine, and then they're dry.

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

Here's the twist that makes this more than just a labour-market story. AI, the very thing that deleted the junior, is itself useless without seniors.

An AI coding tool is a multiplier. It accelerates someone who already knows what good looks like, who can spot the subtle bug in generated code, who knows which 10% of the output is load-bearing and which 90% is plausible nonsense. Hand that same tool to someone with no judgement and it confidently helps them build the wrong thing faster. AI doesn't reduce the need for senior judgement — it raises it, because now there's ten times more code to supervise and a machine that's wrong in extremely convincing ways.

So the industry has built a machine that (a) requires senior engineers to be used safely, and (b) is busy dismantling the only pipeline that produces senior engineers. We are spending the existing stock of seniors to run AI, while AI quietly ensures fewer of them get made. That's not a productivity boom. That's eating the seed corn and calling it a harvest.

The math of a pipeline that stops refilling

Demographics are boring and merciless. Engineers retire, move into management, change careers, or burn out — call it a few percent of the senior pool leaving every year. In a healthy industry, that outflow is replaced from below: juniors hired, trained, and matured into seniors over five-to-eight years. The pyramid stays standing because its base is wide.

Saw off the base — let AI absorb the entry-level work and stop hiring at the bottom — and the pyramid doesn't collapse tomorrow. It collapses on a delay. For the first few years nothing visibly changes: you still have all your seniors, AI made them faster, and you saved a fortune skipping the juniors. Then the seniors start leaving at the normal rate, and for the first time there's nobody behind them. The pyramid is now balancing on its point. That's the position the industry is quietly walking into right now, one rational AI-assisted hiring decision at a time.

What this actually costs — and who pays

The fresh graduates pay first and most obviously. An entire generation of capable, eager people are told the bottom rung no longer exists — the work they'd have learned on is done by a model, and the only acceptable level of experience is "more than they could possibly have." A lot of them quietly route out of the profession before they ever start.

But the companies pay too, just on a delay. The senior they didn't grow today is the senior they can't find or afford in 2035. Salaries for genuine deep expertise will keep climbing — not because the work got harder, but because the supply got automated into scarcity. Software quality drops industry-wide as more of it is built by people who never had anyone senior to learn from, supervising AI they're not equipped to question. The field gets shallower at the exact moment the systems it builds get more critical.

And here's the cruel part: by the time the shortage is obvious enough to act on, the fix takes a decade. You can't microwave a senior engineer, and you certainly can't prompt one into existence. The only way to have one in 2035 is to start growing them in 2026 — which means the cheapest moment to fix this was years ago, and the second cheapest moment is now.

So what does a sane company actually do?

None of this is an argument against AI, and none of it is an argument for hiring juniors out of charity. It's an argument that in a world where everyone else uses AI to delete the junior, the companies that use AI to accelerate the junior will be the only ones with engineers in ten years. That's not sentiment. That's a moat.

This is the model we believe in at Heartbyte, and not for sentimental reasons. We use AI heavily — and we grow our engineers deliberately, because deep senior judgement is what lets us point AI at the right problem and catch it when it's confidently wrong. You can't buy that pipeline on the open market once it's run dry. You can only have built one while everyone else was busy letting a model do the teaching.

The honest version

Nobody set out to break the engineering talent pipeline. That's what makes it dangerous. It's the sum of a thousand individually reasonable, AI-assisted choices — let the model do the junior work, skip the junior hire, let the senior mentor a chatbot instead of a person — each of which makes perfect sense for one company in one quarter, and which together dismantle the machine that produces the very people everyone, and every AI, depends on.

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