Keep Hiring Juniors. Yes, Still. Especially Now.

Every engineering leader I talk to lately has quietly made the same decision: freeze junior hiring, let the agents do the grunt work, hire seniors when we need people. Nobody announces it. It just shows up in the req list.

The data says this is now the industry's default posture. Entry-level hiring at the fifteen biggest tech firms fell about 25% from 2023 to 2024, and Stanford researchers found employment for developers aged 22–25 dropped nearly 20% between late 2022 and mid-2025. A Harvard study covering 62 million workers found that when companies adopt generative AI, junior developer employment falls roughly 9–10% within six quarters. Employer sentiment toward new grads is the most pessimistic it's been since 2020, per NACE's 2026 outlook.

I think this consensus is wrong, and I think the orgs that break from it will be visibly stronger in three years. Not for sentimental reasons. For mechanical ones.

The math everyone is skipping

Your senior engineers came from somewhere. They were juniors who spent years absorbing judgment — reading production incidents, watching a bad abstraction rot, learning why the deploy process has that weird step. The industry's senior talent pool is a pipeline with a decade of latency, and we are, right now, collectively shutting off the intake valve while planning to hire from the output side indefinitely.

That works for any single company in any single year. It cannot work for the industry over a decade, and it won't work for you either, because in a few years everyone will be bidding on the same shrinking pool of people who got their reps in before the freeze. You'll pay the market-wide clearing price for judgment that you declined to grow at a fraction of the cost.

Notably, the same Stanford data shows employment for workers 30+ in AI-heavy roles grew over the same period. AI isn't eliminating engineering work. It's concentrating value in exactly the judgment that only develops through years of supervised practice — the practice we're eliminating.

"But agents do the junior work now"

This is the strongest version of the objection, so let's take it seriously. It's true: the classic junior on-ramp — small bugs, boilerplate, test coverage, mechanical refactors — is precisely what coding agents eat first. If your onboarding model is "give them tickets an agent could do," then yes, that model is dead.

But that was always a lazy onboarding model. It trained typing, mostly, and juniors learned judgment despite it, by osmosis. The honest conclusion isn't "we don't need juniors." It's "we need to onboard juniors on purpose now, because the accidental method stopped working."

And here's what the freeze crowd is missing: agents make juniors more productive, not less relevant. A junior with a coding agent ships like a mid-level engineer on well-specified work. What they can't yet do is specify the work, judge the output, and know when the agent is confidently wrong. Those are trainable skills — and cheaper to train than ever, because the agent handles the mechanical layer while the human learns the judgment layer.

What the redesigned on-ramp looks like

Concretely, this is what I'd build:

Put juniors on review before authorship. Their first weeks should include reviewing agent-generated PRs alongside a senior, with the senior narrating what they check and why. Reviewing is now a core production skill, and it front-loads exposure to the codebase's conventions and traps.

Make them write the handoffs. Have juniors turn vague requests into agent-executable task specs, then run them. Bad spec, bad output — and the feedback loop is minutes, not weeks. This is the fastest judgment-building exercise I know of, because specification failures are visible and cheap.

Give them the code nobody wants. Legacy characterization, test back-fill, documentation of tribal knowledge — work that's high-learning, agent-assisted, and low-blast-radius. They build a map of the system while producing things the team actually needs.

Measure them on judgment, not volume. Lines shipped is a meaningless junior metric when an agent writes the lines. What you want trending upward: rework rate on their delegated tasks, quality of their task specs, and how often their reviews catch real issues.

None of this is expensive. It's a deliberate twelve-month curriculum instead of a ticket queue, plus senior time you should honestly be spending anyway.

The takeaway

The Harvard numbers suggest most of the junior hiring collapse is macro-driven — budgets and rates — with AI as roughly a ten-percent accelerant and a hundred-percent excuse. That means this is a choice, not an inevitability, and choices can be contrarian. Hire a small junior cohort. Redesign the on-ramp around specification, review, and judgment instead of typing. In three years you'll have mid-level engineers fluent in agent-era workflows, at below-market cost, with loyalty you can't buy — while your competitors discover that the senior market got very, very expensive.

The pipeline you save will be your own.

Sources: [IEEE Spectrum on entry-level hiring](https://spectrum.ieee.org/ai-effect-entry-level-jobs), [Stanford/Harvard data summarized by SoftwareSeni](https://www.softwareseni.com/what-the-data-actually-shows-about-ai-and-junior-developer-employment-decline/), [Stack Overflow: AI vs Gen Z](https://stackoverflow.blog/2025/12/26/ai-vs-gen-z/)