Junior developer roles are disappearing. We’re watching the bottom rung of the career ladder quietly vanish. For some, this moment feels like an early signal of a larger and more unsettling shift, where AI encroaches on broad categories of white-collar work. The disappearance of junior developer roles is increasingly seen as a concrete, visible example of that broader trend.
However, I feel like this conclusion requires conflating two things that are happening simultaneously. The first is that we’re going through a massive tech recession. Having personally experienced the pain of the dot-com bust, I can attest to the fact that the bottom rungs of the career ladder simply disappear during these phases. The tech economy is working through an overhang of capacity vs. demand, and the juniors are going to suffer the most.
The second and more permanent shift is that the nature of software development has changed. The task of writing code looks different now, and it’s not going back. As coding itself evolves, so does the path into the profession. The old way of starting out, where junior developers started with clearly scoped tasks to build experience, no longer exists. That rung is gone. The math doesn’t pencil out. If you need to reduce team size or increase output, you’re not going to invest in someone whose initial contributions won’t be worth the overhead.
This reality is leading to widespread concern about how we’ll train junior developers into the next generation of senior developers who can drive AI agents properly. But I think this worry misses the point. The fundamentals of engineering still hold: breaking down complex problems, defining interfaces, and making judgment calls haven’t gone away. If anything, they’ve become more important.
The real change is in execution. The work of typing out detailed implementations is shifting to AI. We don’t need engineers who just follow specs. We need people who can take a loosely defined goal, collaborate with humans and agents, and get to something that works, both technically and in terms of product impact.
Despite the shifting nature of software engineering breaking the traditional junior developer path, the bottom rung hasn’t vanished entirely, it’s just changed. Junior developers with nascent leadership-oriented skills will still grow. They might write less code directly, but they’ll be responsible for outcomes, agent behavior, and quality. The learning still happens. The path is still there. It just looks different now.
We’ve struggled with hiring good junior developers in the past. We found that technical skill, as detected by normal interviews—code projects, knowledge questions, LeetCode, etc.—is a very poor predictor of success on the job. We eventually landed on the term “conscientiousness” to describe what was really important to us. Even that’s not quite the right word. It’s more than diligence. It’s being able to identify the real goals behind a task, ensure that the implementation meets those goals, and raise questions when something doesn’t make sense.
The need for these qualities aligns with something I’ve believed for a long time: even your most junior developers must understand what your product does and why. Ideally, they’ve spent time actually using it. They’ll be making hundreds of little decisions in the codebase, and the best way to get those decisions right is to make sure the decision-makers understand the purpose.
The need to understand has always been true, but it’s even more important now. Junior developers can’t just write code anymore, they must take responsibility for the outputs of AI systems. Which makes it especially ironic is that so many companies are currently doubling down on brutal interview loops, gatekeeping with LeetCode hard problems, and expecting polished, perfect answers. It’s exactly the wrong skillset for the world we’re heading into. Those extremely difficult coding exercises are only useful as a blunt filter when you’re drowning in applicants. They have nothing to do with the skills that matter now: communication, judgment, trust, ownership. Human things. Showing up. Caring about product-level outcomes.
Junior developers with nascent abilities in product-focused leadership areas will thrive and grow. They’ll start with smaller features, take responsibility for outcomes, and learn how to guide and verify agent output. They may write fewer lines of code directly, but they’ll still be accountable for what gets shipped. The learning and experience still happen. The path still exists. But it looks different.
Every project I’ve ever worked on has had a functionally infinite backlog. Most of the time, the reason we don’t do something is because the cost to implement outweighs the expected impact. But if you dramatically reduce the cost of implementation, that equation starts to shift. More of that backlog becomes viable. And when that happens, I believe we’ll start hiring junior developers in meaningful numbers again.
We’ll need them. The best organizations will train them. And the ones that get it right will be the ones that understand what junior developers have always brought to the table, just updated for the world we’re now in.