The Case for Hiring Junior Engineers 🌱

Let's flip the narrative that you only need seniors now.

One of the dominant narratives in software today is that AI is making junior engineers redundant.

It goes like this: since AI can approximate well what a junior engineer is able to produce, there is no point in hiring anyone who is not senior. In fact, senior engineers are the only ones capable of steering these tools.

From what I can see, this story is real, in the sense that many people believe it. I know many companies who have frozen junior hiring, and others who are explicitly steering towards small, senior-heavy teams.

I believe this is a mistake. And I don’t mean it from an ethical angle (the poor junior engineers!) — I mean from a practical, business one.

It’s also a mistake I have seen being done many times, well before AI, pretty much based on the same arguments. If anything, AI supercharged some of the same fallacies that have been around for decades.

Also, I am not alone in this. If you have been following Refactoring, you know the junior engineers topic is a recurring one both in the newsletter and in podcast interviews. Over time, I discussed it with Chris Lattner, Charity Majors, Meri Williams, and more.

So today I will put everything together and make the definitive case for hiring junior engineers on your team in 2026! Here is the agenda:

1. 🏋️‍♂️ Juniors are required to do more now — let’s acknowledge where this is all coming from.

2. ⚖️ Junior vs senior engineers — the difference is messier than you think

3. 🔭 First vs second-order effects — thinking of your team as a system when it comes to process, hiring, and growth.

4. 🌱 How to make it work — because juniors just don’t turn into seniors automatically.

Let’s dive in!

---

🏋️‍♂️ Juniors are indeed required to do more now

Let’s start by acknowledging the obvious: all engineers, not just junior ones, are required to do more now.

More of what? For junior engineers, the job looks qualitatively very different, and requires a lot of things from them *earlier* in their careers than it used to.

Think of:

• Code reviews — because of AI, junior engineers need now to review code from the get-go. Which in turn requires more... 👇

• Critical thinking — engineers need to constantly question the why and how provided by AI.

• Systems thinking — people are given bigger pieces of work from the start, which requires them to employ non-obvious design chops.

This is what many people see and makes them say: “yeah, junior engineers are screwed”.

I don’t think that’s the case, because there’s more to junior engineers than coding 👇

---

⚖️ Junior vs senior engineers

Anyone who has worked for some time in teams with mixed levels of expertise knows that the frontier, or boundaries, between a junior and a senior engineer is not clear-cut. It’s jagged.

Engineers do not grow linearly, simply becoming more capable over time. As humans, we also lose things over time. In my experience, there are things at which senior engineers are, on average, worse than junior engineers.

Many senior engineers are, vs junior engineers:

• More resistant to change

• More biased towards doing things the “old way” (tech choices, processes, you name it)

• Less energetic and hard-working

• Less willing to do the boring but necessary work that exists in all teams

Conversely, junior engineers may lack part of what is needed to steer AI towards quality and safety, but are often better at using it as a whole. They have no bias and adapt faster because, simply put, they have less to unlearn.

They have an easier time keeping their intuition up to date about how to use agents, orchestrate them, and create autonomous loops. Are these loops designed for quality and sustainability? Probably not! But, on the contrary, I know many 15-years-of-exp developers who simply refuse to build loops at all, because they want to retain control over every single LOC, which is wrong just as well.

That’s all to say that the comparison between juniors and seniors is complicated, and is wildly dependent on individuals.

Furthermore, so far we have only talked about production — the things that engineers actually make. But that’s only the immediate, first-order output of your team.

Team success is also driven by processes, cost, hiring & retention, individuals’ growth, and all kinds of system-level factors that are often neglected in this conversation.

What is your team going to look like one year from now? What about two years? How does that change based on the level of seniority mix you design your team for? I know companies that are more or less intentionally refusing to plan for longer than a quarter, because of AI uncertainty and all. But I don’t think that can be an excuse. As Eisenhower said: “Plans are useless, but planning is indispensable”.

So let’s try to loop all of this in 👇

---

🔀 Second-order effects of mixing seniority

Out of the various parts of your team life that are “not coding”, there are three that are particularly relevant when it comes to seniority levels, and it’s process, hiring, and growth.

1) Process

In my experience, the teams that are best at designing and enforcing good dev process are those with a healthy mix of seniority. In fact, both extremes are often bad:

• Junior-heavy teams — often would love good process, but don’t know what it looks like.

• Senior-heavy teams — know what good process looks like, but they can bridge gaps with individual experience and knowledge, so have less incentive to make things explicit and robust.

Mixed, diverse teams have both the senior folks who can design process, and the junior ones to benefit.

Needless to say, process, guardrails, devex, and all that jazz today is 10x more important than in the past, because that’s also how you scale AI work (the “harness”!).

2) Hiring

Senior engineers are hard to find and hire: you are competing for a limited pool of talent, and the pipeline is long and expensive. No way around it.

Conversely, junior engineers come from predictable, controllable hiring channels, like universities, bootcamps, and the likes. They are both cheaper and faster to hire.

3) Growth

Junior engineers can grow into the specific mix of duties and skills that your company needs, often compensating for the lack of experience with this special fit that is hard to replicate by hiring a senior. Even worse, a senior engineer who is already invested in a set of technologies and practices may have little interest in steering towards how your team does things.

Junior engineers are also easier to keep engaged, growing, and happy for a long time, simply because the bar for work that makes them grow is lower than for a senior. In any company there is a ceiling to what an engineer can learn, and senior folks just leave when they stop growing. In a healthy mixed team, senior departures are compensated by juniors who have risen through the ranks, and eventually replaced the former.

---

🌱 How to Make It Work

So, as Martin Fowler put it on the podcast, one of the most important qualities of junior engineers is to eventually turn into senior engineers. That said, this doesn’t happen automatically.

While there exists, indeed, a dream scenario in which junior engineers grow, become senior, and *rotate* your headcount to compensate other senior departures, in circle-of-life fashion, there is also a nightmarish scenario in which juniors are thrown in the trenches, abuse AI in ways they don’t understand, nobody checks on them, and the product and tech eventually goes to shit.

When this cycle breaks, it’s because junior engineers don’t have enough feedback loop to 1) ensure their work is high quality, and 2) learn and grow from doing it.

The way to create this feedback loop, to me, looks like two-fold:

• Invest in an amazing harness — create guardrails, rules, gates, and encode everything that can ensure quality automatically. This benefits just about everyone: senior engineers, AI, and junior engineers who can learn from those same rules.

• Pair juniors with seniors — let young folks experiment and work fast, but pair them with seniors to provide judgment and systems thinking. It’s still early days for this and everyone needs to find their own formula, but e.g. I loved Rick Clegg’s talk about what they do at Wise about it.

---

📚 Resources

I got plenty of resources about this if you want to deep-dive more:

• Scaling Juniors in the AI Era — the aforementioned talk by Rick Clegg from Wise about using automate guardrails to let junior engineers ship faster with AI.

• You Don’t Hire Juniors to Do Menial Chores — great piece by Frederick Van Brabant about how juniors help innovation: they bring fresh takes to many things, and stress-test your assumptions because they have not yet learned all your bad habits.

• Diversity, AI, and Junior Engineers — my interview with the awesome Meri Williams, where we talked a lot about growing engineers.

• In Praise of Normal Engineers — the incredible article that Charity Majors wrote for Refactoring, where she argues we should hire the “right” people instead of the “best” ones, and invest in 10x teams, instead of 10x engineers.

---

📌 Bottom line

And that’s it for today! Here are the main takeaways:

• ⚖️ The junior vs senior frontier is jagged, not linear — engineers don’t simply get better at everything over time. Seniors gain experience but often become more resistant to change and harder to keep engaged, while juniors adapt faster, have less to unlearn, and are often better at embracing AI workflows.

• 🔄 Mixed-seniority teams build the best processes — senior-heavy teams have less incentive to make knowledge explicit and systematic, while junior-heavy teams don’t know what good looks like. You need both. Also, robust, explicit process is exactly what scales AI work.

• 💰 Junior hiring is cheaper, faster, and more sustainable — instead of competing for a scarce pool of senior talent, you can hire juniors from predictable channels and grow them into the specific shape your company needs, creating a circle-of-life rotation that compensates senior departures.

• 🛡️ Invest in the harness, not just the horse — the way to make junior engineers thrive is to build amazing guardrails (automated quality gates, rules, standards) and pair them with seniors who provide judgment and systems thinking.

• 🔮 Refusing to hire juniors is a bet against your own future — if you only hire senior engineers today, you are optimizing for short-term output while starving the pipeline that will sustain your team for years to come.

---

See you next week!

Sincerely 👋
Luca