The Bet On Juniors Just Got Better
Why genies can make hiring juniors more profitable, & what you need to change to get there
Junior developer—obsolete accessory or valuable investment? How does the genie change the analysis?
Folks are taking knee-jerk action around the advent of AI—slowing hiring, firing all the juniors, cancelling internship programs. Instead, let’s think about this a second.
The standard model says junior developers are expensive. You pay senior salaries for negative productivity while they learn. They ask questions. They break things. They need code review. In an augmented development world, the difference between juniors & seniors is just too large & the cost of the juniors just too high.
Wrongo. That’s backwards. Here’s why.
Oops, I buried my lede. Here’s my number one lesson—manage juniors for learning, not production.
The Valley of Regret
A junior developer is a bet. You’re paying money today for productivity tomorrow. The shape of that bet looks something like this:
That red zone—the “valley of regret”—is where things go wrong. You’re spending money. You’re investing senior attention. And every month the junior is in that valley, something can happen: they get a better offer, they decide engineering isn’t for them, your startup runs out of runway, there’s a layoff.
The longer & deeper the valley, the more likely you never reach the other side.
This is why, when I talk to engineering managers, I hear the same thing: “We’d love to hire juniors, but we can’t afford the ramp time right now.”
Shrinking the Valley
I’ve been watching junior developers use AI coding assistants well. Not vibe coding—not accepting whatever the AI spits out. Augmented coding: using AI to accelerate learning while maintaining quality. Remember, you’re managing for learning, not production.
Managed for learning, the magnitude of the junior bet changes:
The juniors working this way compress their ramp dramatically. Tasks that used to take days take hours. Not because the AI does the work, but because the AI collapses the search space. Instead of spending three hours figuring out which API to use, they spend twenty minutes evaluating options the AI surfaced. The time freed this way isn’t invested in another unprofitable feature, though, it’s invested in learning.
Learning fast can become a habit. When a task is “completed”, there is always the opportunity to squeeze more juice from it:
How else could this have been done?
Is there now a way to simplify the code?
What are the tradeoffs?
Are there more tests we can/should write?
What is the performance envelope?
The genie is an endlessly patient tutor, but unlikely to volunteer learning opportunities. We’ll talk at the end of this piece about why learning like this is rare & what you need to change to realize the potential of juniors. It’s not just going to happen by itself.
First Order: More Value
Shortening the valley isn’t just “you get productivity sooner.” It’s that you survive the valley at all. (See also Luca Dellanna’s Ergodicity.)
Junior developers have high turnover. Let’s say 20% annual attrition—low for tech. Run the numbers:
Traditional 24-month ramp: About 36% of juniors leave before they ever become net positive. More than a third of your bets never pay off.
Compressed 9-month ramp: About 15% leave before breakeven. You’ve cut your failure rate by more than half. Of the juniors who pass break even, more of that profitable area comes back to the company.
You’re not just getting productivity 15 months earlier. You’re dramatically increasing the probability that you realize profitability at all.
The shorter the valley of regret, the more juniors survive the crossing.
Second Order: Faster Growth
There’s another factor a simple model of junior productivity misses. Productive developers don’t just produce—they multiply.
A developer who reaches payoff productivity doesn’t just write code. They mentor other juniors. They build institutional knowledge. They take on projects that create leverage for the whole team. Every month you accelerate one developer’s ramp, you’re also accelerating the ramp of everyone they’ll eventually help.
What This Means
If you’re an engineering manager thinking about hiring:
The junior bet has gotten better. Not because juniors have changed, but because the genie, used well, accelerates learning.
Investment in tooling is investment in hiring. The ROI on getting your AI tooling right isn’t just “existing developers are more productive.” It’s “we can now make profitable bets on juniors that we couldn’t make before.”
The math favors action. In high-attrition environments especially, the expected value of a junior hire has shifted. You’re no longer betting against the valley of death—you’re shortening it.
But you have to actually do it. The compressed ramp doesn’t happen automatically. It requires intentional investment in how juniors learn using the genie. Not vibe coding—augmented coding. That’s a skill, and you have to teach it, encourage it, refine it.
The bet has gotten better. Better if you manage juniors for learning & not production.
If you found this useful, you might enjoy my other writing on augmented coding and how AI is changing software development. And if you’re an engineering leader thinking about how to make these bets in your organization, that’s exactly the kind of thing I work on with companies, whether through this newsletter or in-person with consulting, advising, and coaching.
Today’s post is sponsored by CodeRabbit. Boost your team’s code quality and shipping speed with CodeRabbit—the most advanced AI code review tool built for engineers. CodeRabbit delivers context-aware, line-by-line reviews, instant one-click fixes, and concise PR summaries, integrating right into your GitHub workflow so you spend less time diff diving and more time building.
Ready to optimize your engineering workflow?
Join thousands of developers who’ve halved code review time and defect rates with CodeRabbit. Start your 14-day free trial and experience seamless AI reviews, actionable feedback, and effortless codebase learning.
I might have misunderstood the idea but it seams to me you're saying AI can teach juniors how to code properly.
By "properly" I don't mean syntax, using libraries or peripheral stuff like bash scripts & SQL. I mean understanding abstraction levels, coupling/cohesion, testability, consistent DSL-s throughout the codebase - things LLMs get right only a fraction of the time (in my experience) and it takes a seasoned professional to spot the difference.
When an organisation wants to cut their investment in juniors (and expect the same returns), they've already taken the wrong path.
Some teams use juniors to reduce the amount of time senior developers have to deal with toil, and I expect that as AI is good in dealing with toil, the need for hiring a bunch of people to deal with toil will decrease.
Other teams are using juniors to do interesting projects, especially interesting projects that are not that tied up in the main business logic - of which there are many - while having seniors do the organisational work of making all of these projects turn into a useful product. That requires a culture that empowers juniors to learn and be creative, but is pretty powerful and becomes even more powerful with AI, as people with less experience are better able to take up projects in new areas.