Junior developers and AI

Generative AI has filled the world with code. Unfortunately, enough of it is bad code that you’re still going to need experienced developers who can fix the errors introduced by genAI. But what about junior developers? What’s their role in a world awash in machine-generated code that, at least in theory, renders less experienced developers less valuable?

As Honeycomb co-founder and CTO Charity Majors argues, we’re at a key inflection point for software development. However much folks may bluster about AI replacing software developers, that’s absolutely untrue for senior developers. “Being a senior engineer is not primarily a function of your ability to write code,” she notes. “It has far more to do with your ability to understand, maintain, explain, and manage a large body of software in production over time, as well as the ability to translate business needs into technical implementation.”

And what about junior developers? This is where short-term thinking that AI can replace junior developers can create long-term problems. “By not hiring and training up junior engineers, we are cannibalizing our own future,” Majors insists. We may be doing so because we fundamentally misunderstand what software developers do, and we overlook the impact junior engineers have on teams.

The less code the better

Software developers, after all, don’t actually write much code. Or they shouldn’t. Channeling Majors’ comment above, a big part of software development comes down to requirements gathering. In an optimistic estimate, a Tidelift survey found developers spend 39% of their time writing new code. That’s much higher than most estimates I’ve seen. Given the need for design, reviews, maintenance, etc., the actual time spent adding new code ends up occupying a minority of a developer’s time, which is good, because the best code is the code you don’t have to write because you’ve reduced the problem to a minimum. This means less code to maintain, less code susceptible to bugs or hacks, etc. (This, incidentally, is one problem with genAI-driven code: It tends to be overly verbose.)

“Writing code is the easiest part of software engineering,” Majors notes, and genAI has made writing code faster than ever. That’s good. It’s also bad. GenAI has done nothing, she points out, “to aid in the work of managing, understanding, or operating that code. If anything, it has only made the hard jobs harder.”

This isn’t great for junior developers or senior developers.

It takes all kinds

Here’s the thing: If we want senior engineers, we’re going to need to train junior engineers. That’s how it works. That’s the deal. Majors offers a number of reasons why this is worth the bother and settles on a few long-term arguments for hiring junior engineers:

• We need more senior engineers as an industry.
• Somebody has to train them.
• Junior engineers are cheaper.
• They may add some much-needed diversity.
• They are often very loyal to companies who invest in training them, and they may stick around for years instead of job hopping.
• Did we already mention that somebody needs to do it?

Now think about these points against her two big propositions. First: “Software engineering is about transforming business problems into technical ones.” Second: “The product of software engineering teams is shared understanding.” Both propositions mean that although genAI can play a role in creating code, it cannot replace the heart of software engineering, which is about human understanding of business problems and human collaboration to resolve those problems.

In both areas, junior developers can play a big role.

Junior developers are an important part of a team. “Hiring engineers is about composing teams,” Majors stresses, and “a good team is composed of a range of skills and levels.” You need people to make the big decisions, yes, but you also need folks for whom documentation and other “low-level tasks” are a stretch and push their boundaries. You need people who won’t immediately understand why a senior engineer does something, so the senior engineer must explain her work. No team will function well for long with only senior engineers, and no developer will become a senior engineer by skipping her junior development years because genAI did all the work.

We need more junior developers. Not for their code, per se—code is the easiest problem to solve. No, we need more junior developers because of their impact on teams right now, and because eventually, they’ll become the senior developers your business depends on.