Hire Juniors.

By Alexander Luksidadi

Last Friday we posted a junior software engineer role. Less than a week later, we have over 2,000 applicants.

Last year, the same posting took two weeks to hit 2,000. This year it took less than one. And a lot of the people applying aren't juniors at all. They're experienced engineers, some of them senior, applying for an entry-level role.

That's not a hiring funnel. That's a market telling you something.

The door is closing

Every source I looked at points the same way.

Only 4.5% of software development job postings are entry level, the lowest share of any sector. New-grad hiring at the biggest tech companies is down about 65% from 2019, and at early-stage startups it's down about 76%. Here in Canada, job postings for coding roles needing three years of experience or less fell by roughly 60% in under three years.

Even the AI labs are doing it. Anthropic published its own numbers last month: juniors went from 27% of its technical hires to 9% in about a year. And the authors are honest that none of their proposed responses fix that.

Sources: SignalFire 2026, Statistics Canada (Jan 2026), Anthropic (Oct 2026). Anthropic's drop is computed from 27% to 9%.

Meanwhile, the kids who picked computer science during the "we can't hire enough engineers" years are graduating right into it. US universities just produced a record number of CS graduates, up nearly 50% from 2020. They did exactly what we told them to do. Then most of the industry stopped hiring them.

It isn't (mostly) AI

The easy story is that AI took the junior jobs. Senior engineer plus agents equals no need for juniors.

The data doesn't really support it. The New York Fed looked at job postings and found AI is not the main driver of the hiring slowdown. Another New York Fed study found that the biggest single factor behind rising unemployment for young graduates is remote work: about 64% of the increase. The mechanism is simple. Juniors learn by sitting next to people who know more than they do. Take that away and juniors stop being productive, so companies stop hiring them.

So yes, money got tight and teams got leaner. But a lot of companies didn't lose the ability to grow juniors. They chose to stop doing it.

I think that's a mistake. And I think AI makes it a bigger one.

AI favours the people with less to unlearn

When researchers ran field experiments with AI coding assistants across thousands of developers at Microsoft, Accenture and a Fortune 100 company, the junior developers got the biggest boost: 27 to 39% more output, against 8 to 13% for seniors. Juniors also adopted the tools faster.

Source: Cui, Demirer et al., GitHub Copilot field experiments at Microsoft, Accenture and a Fortune 100 firm (MIT Sloan summary). Dot = midpoint of the reported range.

That matches what I see every day. Juniors don't carry ten years of muscle memory about how code is "supposed" to be written. They don't grieve the keyboard. They pick up agents, worktrees and orchestration like it's the normal way to work, because for them it is.

And the job itself has changed. Demand for front-end and mobile specialists has nearly halved in a year, while openings for forward deployed engineers grew 4.6x. Teams are smaller and each engineer owns more of the problem. "LLM" now shows up in more engineering job postings than Java.

Source: Lenny's Newsletter, late 2026 (TrueUp postings data). FDE +360% = 4.6x; front-end and mobile "nearly halved", drawn as about −50%.

The market doesn't want narrow specialists anymore. It wants engineers with range: people who can own a product decision, sit with a customer, and ship the fix.

You don't find many of those. You grow them.

We've done this before

In 2017, we couldn't hire a third senior engineer. No brand, no budget, a quarter of interviews ending in rejected offers. So we asked, "why not hire juniors?" We hired bootcamp grads, scored their take-home projects on thoughtfulness instead of correctness, and our first two juniors went on to run the program.

Back then, hiring juniors was a necessity. A few years later it was a choice.

In 2026, it's a conviction. We're doing it while most of the industry goes the other way, because we've seen what happens when you give a hungry junior real problems.

Rose Rocket's junior hiring, 2017 to today, and the pipeline gap ahead (CS-majors drop: Computing Research Association, Taulbee Survey 2025)

What "real problems" means here

The first thing our last junior cohort built wasn't a ticket from the backlog. It was a simulation of TED, our email-parsing product, so our sales team could demo it to prospects. Their first users were AEs, not engineers.

One of our juniors went deep on the platform. Within months of joining, they owned our config validation system end to end: an eight-layer validator, one layer built on graph algorithms they learned in university and finally got to use. Today they maintain a core part of our platform SDK, review other engineers' work on it, and take their turn on Mission Control, our incident rotation. Nobody handed them "starter" work and waited.

Another went from a junior rotation straight into our Software Factory, the system where AI agents resolve engineering tickets and humans verify the output. They rebuilt part of its orchestration, built its first real evaluation dataset, and built their own dashboard to watch the agents work. Stuck once on a failing end-to-end test, they had Claude bisect the branch against main in a loop, went to dinner, and came back to the exact line that broke it.

Their own agent launcher: pick a feature, see every agent session on it from scope to ship, and start a new worker from one prompt. Shown with dummy data.

Steering a worker mid-run instead of babysitting it.

A third shipped more than ten customer integrations in a month. Not by typing faster. They built their own orchestration setup, one agent per integration running in parallel, so they could spend their time on the hard mapping problems instead of the plumbing. They also built tooling that clones a customer's production setup with anonymised data, so an agent can reproduce a customer's problem safely.

"The Den": every office is a live run, every beaver is an agent. Customer names blurred.

One run, start to PR: who did what, how long it took and what it cost.

Then two of them did something I'm genuinely proud of. On top of the foundation one of our engineering manager and I built, they built Beaver v2: the version of our Software Factory that people outside engineering actually use. It's far more pleasant to work with, far more reliable, and it helps our customer success team get things done faster without waiting in an engineering queue.

The juniors didn't get automated away by the software factory. They're the ones who took it over the finish line.

One of them is moving on to their next chapter this month. Before they go, they're leaving their "second brain" behind, the agent setup and context they built, so it keeps doing their work after they've gone. A junior who automated themselves so well that they keep contributing after they leave. I can't think of a better review.

The "second brain" they're leaving behind: every project, run and memory, linked. Labels blurred.

What it actually takes

None of this happens by accident, and I won't pretend we got it right the first time.

A year ago, our juniors spent their first three months on maintenance tickets, and the hard problems kept going to the same senior engineers. We cut that to one month and put juniors on real projects, paired with senior and staff engineers. One of our seniors also pointed out a real risk: juniors accepting AI output they don't fully understand. The fix wasn't to take the AI away. It was mentorship: weekly one-on-ones, pairing, rigorous code review, and a simple rule in our engineering framework: understand and verify before you ask for review.

We also stayed in the office on a fixed hybrid schedule, partly for exactly this reason. Juniors grow from the unscheduled conversation and the whiteboard session. The Fed data says the same thing.

The other half is exposure. Our juniors join incident response, write and defend RFCs in our weekly review, make big and risky production changes, sit with customers, and make product and design calls. They're trusted to solve problems anywhere in the company, including sales and customer success. That trust is the program.

Who we're looking for

We're not hiring for a degree or a stack. We're hiring for three things:

• High agency. You don't wait to be told. You find the problem and you fix it.

• High curiosity. You build things nobody asked you to, and you want to know how everything works.

• High motivation to solve real problems, for the company or for a customer.

If that's you, we'd love to meet you. Apply here: Junior Software Engineer at Rose Rocket.

And if you're a CTO deciding whether to freeze junior hiring: the CS enrollment wave is already reversing, with new CS majors down about 13% this year. In four or five years, everyone will be fighting over mid-level engineers who know how to work with agents. The only way to have them then is to start growing them now.

Hire Juniors.