Everyone agrees AI makes senior engineers more valuable. Almost nobody asks where the next generation of seniors is supposed to come from. The work AI automated away was never waste, it was the apprenticeship, and the hiring data says the bottom rung is already gone.
There's a story the industry loves telling right now: AI makes senior engineers more valuable. The people with judgment, the ones who can smell a bad design from the doorway, are the winners of this shift. It's a comforting story. It's even true.
It just has a hole in the middle big enough to drive a hiring freeze through. Seniors are not a renewable resource. Nobody arrives with fifteen years of scar tissue preinstalled. Every senior you've ever worked with started as a junior who got handed unglamorous work and spent years doing it. And AI has quietly eaten the exact work those years were made of.
This isn't a piece about whether AI writes good code. It writes plenty. It's about what happens to the supply of people who can tell.
Where Seniors Actually Come From
Ask a senior engineer what made them senior and you won't hear "a certification." You'll hear about systems they broke, incidents they sat through, codebases they had to read for weeks before anything made sense. Judgment isn't downloaded. It's accumulated through thousands of small collisions with real systems, most of them unglamorous, many of them boring at the time.
That's the part the "seniors win" narrative skips. It treats senior supply like weather, something that's just out there, replenishing itself. It isn't. It's manufactured. Slowly, expensively, by teams that gave someone a bottom rung to stand on and tolerated the wobble.
Your hiring plan probably assumes that when you need seniors in 2030, you'll hire them from the market. Fine. But the market is just other companies' former juniors. Someone, somewhere, has to be running the apprenticeship, or there's nothing to hire.
The Grunt Work Was the Curriculum
Think about what a junior developer's week actually looked like before AI tooling got good:
- Boilerplate - scaffolding CRUD endpoints and form validation taught the shape of the framework, where things live, what the conventions are and why they exist.
- Small bug fixes - the ticket nobody wanted taught you to read stack traces, then logs, then, crucially, other people's code. Not the code you'd write. The code that's actually there.
- Glue code - wiring service A to queue B taught how systems really connect: timeouts, retries, the config value that only matters in production.
- Tracing someone else's code - the "figure out why this happens" tasks built the mental model of the system that every future architecture decision would lean on.
- PR nitpicks - forty comments on your first pull request stung, and they were also the fastest taste-transfer mechanism the industry ever had.
Nobody defended this work. We called it toil, grunt work, the stuff you paid your dues on. So when AI showed up and started doing all of it in seconds, we celebrated. Finally, juniors can skip the boring parts and do the real engineering.
Except the boring parts were the training. An apprentice electrician spends years pulling cable and mounting boxes. Not because the master can't do it faster, but because that's how you learn how buildings actually work before anyone lets you near a panel that can kill you. Hand the cable-pulling to a robot and you still get wired buildings. You just stop getting electricians.
That's what the automation did. It didn't trim waste. It deleted the curriculum and kept the exam.
And it leaves today's juniors in a strange trap: with AI, they can produce more output than any junior in history, while collecting fewer reps than any junior in history. Output was never the point of junior work. The learning was the product; the tickets were just the delivery mechanism.
The Numbers Are Already In
This would be a hand-wavy think piece if the data weren't already showing it. It is, and from several independent directions.
SignalFire's State of Tech Talent report found that new graduates now make up just 7% of hires at Big Tech companies, with new grad hiring down more than 50% from pre-pandemic 2019 levels. The report also surfaced the quiet part said out loud: 37% of managers said they'd rather use AI than hire a Gen Z employee.
A Stanford team led by Erik Brynjolfsson analyzed payroll data from ADP, covering millions of workers, and found that early-career workers aged 22 to 25 in the most AI-exposed occupations saw a 16% relative decline in employment since late 2022. Software engineering is one of the flagship examples. Meanwhile, workers 30 and over in those same occupations grew 6 to 12% through May 2025. Same jobs, opposite directions, split cleanly by age. A recession doesn't check your birth year. AI adoption apparently does.
The downstream effect is visible in graduate outcomes too: New York Fed data puts recent computer science grads at 6.1% unemployment, against a 4.8% average for recent graduates overall. The major an entire generation was told to pick now underperforms the average.
And the sentiment behind those numbers is not subtle. In survey data covered by Stack Overflow, 70% of hiring managers said they believe AI can do an intern's job, and 57% said they trust AI's output more than a recent grad's work.
The bottom rung isn't loosening. It's already off the ladder.
Rational for One, Starving for All
Here's the uncomfortable part: nobody in this story is making a mistake.
Run the math for a single team, this quarter. A junior hire costs a full salary plus a meaningful slice of a senior's week for a year or more before they're net positive, and then they might leave for a 30% raise somewhere else. An AI coding tool costs less than the team's coffee budget and is productive this afternoon. If you're the engineering manager with one open req and a delivery deadline, skipping the junior is the correct decision. Any CFO would sign off on it. Most do.
The problem is that everyone runs the same spreadsheet. Each company individually decides to hire seniors "from the market" instead of growing them, and the market is nothing but the output of other companies' junior programs. Skipping juniors is free-riding on someone else's apprenticeship. It works beautifully right up until it's universal.
This is a commons problem, and the senior pool of 2031 is the commons. No single company owns it, no single company is punished for depleting it this quarter, and no line item on anyone's P&L represents it.
The lag is what makes it dangerous. The juniors not hired in 2025 are the mid-level engineers who won't exist in 2028 and the seniors who won't exist in 2031. And a missing cohort can't be backfilled later, because the thing you'd be hiring is years of accumulated judgment. You can raise a salary band in one budget cycle. You can't raise experience.
"Maybe AI Just Becomes the Senior"
The honest counterargument deserves a fair hearing, because it's not stupid. It goes like this: models are improving fast, so by the time the senior gap arrives, AI will be doing the senior work too. Worrying about the junior pipeline is like worrying about horse-stable capacity in 1910 while Ford ramps up the assembly line.
Take it seriously, and it still breaks on one stubborn fact: someone has to put their name on the merge.
When an AI-generated migration takes down production at 2 a.m., "the model did it" is not an incident report anyone accepts. Not your customers, not your auditors, not the regulator if you're in fintech or healthcare. Accountability is load-bearing in software organizations, and it can't be delegated to a system that can't be fired, deposed, or promoted. Some human reviews the output, approves it, and answers for it.
And review is not a checkbox. Reviewing well means knowing which diffs are risky and which are routine, what the blast radius of a schema change is, when the tests are green because the code is right versus green because they don't test the failure mode. That's judgment. It's precisely the thing the apprenticeship used to produce, in exactly the people we've stopped training.
So the "AI becomes the senior" future eats its own premise: the more code AI writes, the more the human job becomes review, and the industry is currently betting on that skill while dismantling the only machine known to produce it.
The Stanford data has a wrinkle that backs this up: employment held or grew in roles where AI augments people, and workers who used AI to learn and validate their work fared better than those who delegated whole tasks to it. The market is already sorting people, not by whether they use AI, but by whether they use it in a way that builds judgment or replaces it.
Keeping the Apprenticeship Alive
You can't fix industry-wide hiring incentives from your desk. What you can control is whether learning still happens inside the work you and your team already have.
If you're early in your career:
- Struggle first, prompt second. Give every problem a genuine attempt before you ask the model. The struggle is not an inefficiency to optimize away; it's the mechanism that writes the lesson into your head. AI is a phenomenal tutor when it explains something you already fought with, and a lesson-shredder when it answers before you've formed the question.
- Read every AI diff like a reviewer, because you are one. As far as git blame and your team are concerned, you wrote that code. If you can't explain a line in the diff, you're not done. Make understanding the deliverable, not the merge.
- Do some things the slow way, on purpose. Trace the framework call by hand once. Write the migration yourself before asking for one. You're not being a purist, you're doing reps, the same way athletes still lift weights even though forklifts exist.
- Get good at review early. Review is where the job is heading. Volunteer for it, study how the best reviewer on your team comments, and learn to articulate why something is risky. That skill compounds faster than raw output ever will.
If you lead a team:
- Hire one junior, with an actual plan. Not as charity, and not as a body for ticket throughput. A plan: rotations through subsystems, a named mentor with time carved out, attendance at incident reviews. One deliberately-grown junior beats zero on principle and beats three unsupported ones in practice.
- Assign understanding, not just output. Have them present how the payment flow works end to end. Put them on the on-call shadow rotation. Ask them to write the postmortem draft. None of this ships features, and all of it manufactures the thing you'll be desperate to hire in five years.
- Keep the instructive tickets human. Not the soul-crushing ones. Automate those with a clear conscience. But the gnarly little bug in the legacy module that forces someone to actually read the system? That ticket is tuition. Don't spend it on the model.
- Review AI usage together. Look at prompts and diffs in pairs, the way you'd pair on code. How a junior uses the model is their process now; if it's invisible, so are their gaps.
None of this shows up in this quarter's velocity. That's the point. The apprenticeship never showed up in velocity either, which is exactly why it was so easy to automate away without anyone noticing what it was.
The industry didn't decide to stop producing seniors. It automated the thing that produced them, one perfectly rational quarter at a time. The teams that have enough seniors in five years will be the ones that never stopped making them.
P.S. Thanks for taking the time to read this article! The ideas and opinions expressed here are my own. English is not my first language, so I use AI to help correct grammar and make my writing clearer and easier to read. If anything still sounds a little awkward, I appreciate your understanding!
Originally published at nazarboyko.com.
Enjoyed this one? Let's stay in touch - I'm on LinkedIn, always happy to chat, swap ideas, or just say hi. 👋