The pitch sounds airtight. AI writes the boilerplate a junior used to write, so why hire the junior? Skip the ramp-up, skip the reviews that feel like teaching, ship faster with a lean team of seniors and a fleet of models. It’s clean, it’s cheap, and it’s one of the most expensive mistakes a software company can make right now.
Seniors don’t spawn
Every senior engineer you admire was once a junior who was allowed to be slow, allowed to be wrong, allowed to ask the “dumb” question in review. There is no other supply. Stop hiring juniors and you haven’t saved money; you’ve stopped manufacturing the exact people your company will be desperate for in five years, and so has everyone else. The pipeline doesn’t pause politely. It empties.
And someone has to be able to judge the machine’s output. An AI will hand you code that’s confidently, subtly wrong. The person who catches it is a senior, a former junior who earned that instinct by making those mistakes themselves, on purpose, while it was safe.
We have run this experiment before
The “we don’t really need juniors anymore” argument is not new; it just wears new clothes every decade. When the high-level compiler arrived, senior engineers swore the entry-level assembly programmers were finished. When the IDE began autocompleting and catching errors, same eulogy. When Stack Overflow meant a beginner could paste in a working answer they didn’t understand, the industry declared the junior redundant again. When no-code tools promised software without programmers, the obituary ran one more time.
Every one of those tools genuinely did what it claimed: each made the mechanical part of the work faster. And not one of them removed the need for people who grow into the judgment that steers the tool, because that judgment was never the part being automated. AI is the biggest lever yet, which makes the temptation stronger and the mistake more expensive. But it is the same mistake. A tool that makes juniors more productive is not an argument against hiring them; it is the best argument for it you have ever been handed.
Juniors are your smoke detector
There’s a less obvious reason to keep hiring them. A sharp newcomer is the best test of whether your systems actually make sense. If a motivated junior armed with the best AI tools still can’t get productive in your codebase, that is not a junior problem. It’s a design smell you’d otherwise never notice, because your seniors memorized their way around the potholes years ago.
The category error
“AI does junior work” confuses tasks with growth. AI does junior tasks: the boilerplate, the first draft, the lookup. It does not do junior development: the messy, compounding process of a person becoming a senior. The value of a junior was never the boilerplate they produced. It was who they were turning into.
“But juniors slow us down”
This is the real objection hiding under the AI rationalization, and it deserves an honest answer: yes, in the first months, a junior is a net cost. They always were. You are paying, in senior attention, to manufacture a senior. And what changed is that the manufacturing just got dramatically cheaper, which most companies are somehow treating as a reason to stop building the factory.
Here is what using AI well with a junior actually looks like. You don’t hand them the model and walk away; you sit them next to it. Have them generate the first draft and then defend it: explain why each piece is there, predict where it breaks, find the bug you already spotted. Have them review the machine’s output the way a senior reviews theirs, because reviewing is how judgment gets built, and the model produces an endless supply of confident, subtly-wrong material to practice on. The two-year ramp compresses not because the junior thinks less, but because they get ten times the reps at the thinking that matters, beside a partner that never sighs.
The bill arrives for everyone at once
Zoom out from your own team and the individual choice becomes a collective one. If every company independently decides juniors are an AI-era luxury, the whole industry stops producing seniors at the same moment, and in five to seven years there is a violent shortage of exactly the people who can supervise the machines everyone now depends on. You won’t hire your way out of it, because no one will have trained anyone. The companies that quietly kept their pipelines running through this stretch will own the only scarce resource left: people whose judgment AI amplified instead of replaced. That isn’t altruism; it’s the highest-return recruiting strategy nobody is running, because it doesn’t pay off this quarter.
The version that actually wins
Here’s the second-order move most companies are too shortsighted to make. The teams that win the next decade won’t be the ones that squeezed the most tokens out of AI this quarter. They’ll be the ones that used AI to make juniors senior faster, turning a two-year ramp into six months by handing a curious person an infinitely patient tutor, instead of using it as a reason to never let that person in the door.
AI didn’t remove the need for junior developers. It removed your excuse for onboarding them badly. One of those is a strategy. The other is eating your own future to make this quarter look lean. Which one are you actually running?
We think hard about the second-order effects of what we build, including who a tool quietly replaces, and who it could be growing instead. That’s what we do at Rebel Studios.