The junior developer extinction: the missing seniors of 2035

Senior developers are made, not hired. Every experienced developer carries knowledge that cannot be documented—why that particular abstraction exists, why the "obvious" refactor would break hidden dependencies, which mistakes are worth making and which must be avoided. This knowledge transfer happens through years of mentorship: asking questions, pair programming on complex problems, watching experienced developers debug production incidents. It cannot be compressed into documentation or tutorials. It requires time, proximity, and patience.

Now I watch companies eliminate those seats entirely. Junior developer positions have become endangered species, sacrificed on the altar of AI efficiency. The logic seems sound: why hire someone who needs training when an AI can generate code instantly? Why invest in a developer who won't be productive for six months when a language model is productive immediately?

The flaw in this logic is so fundamental that it astonishes me how many intelligent people miss it. Senior developers are not hired. They are grown. Every senior developer you have ever worked with was once a junior who knew nothing, who made stupid mistakes, who needed patient mentorship and years of practice to become valuable. If we stop growing juniors today, we will have no seniors tomorrow.

The numbers tell a stark story. Entry-level developer hiring has collapsed by 73.4% whilst overall tech hiring dropped only 7.4%.¹ A Harvard study examining 285,000 firms found that when companies adopt generative AI, junior employment drops approximately 8% within six quarters—whilst senior employment barely changes.² Stanford's Digital Economy research shows employment among young developers aged 22-25 has declined nearly 20% from its 2022 peak.³ We are witnessing the systematic elimination of the bottom of the career ladder.

This is not a temporary correction. This is a structural shift. According to a recent LeadDev survey, 54% of engineering leaders actively plan to hire fewer juniors because AI copilots enable seniors to handle more work.⁴ Seventy percent of hiring managers believe AI can do intern jobs, and 37% would rather "hire" AI than a recent graduate.⁵ Tech internships have dropped 30% since 2023.⁶ The message to new graduates is clear: you are being replaced before you even start.

The pipeline problem

Here is a question that should keep every CTO awake at night: where will your senior developers come from in 2035?

The typical journey from junior to senior takes five to ten years. A developer needs one to three years to master the basics, another two to four years to develop architectural thinking and mentoring skills, and several more years to build the judgement that comes only from shipping software, watching it break, and learning from the wreckage. There are no shortcuts. You cannot compress this timeline by reading documentation or watching tutorials. The skills that make a senior developer valuable—debugging intuition, system design instincts, the ability to navigate organisational complexity—are developed through practice, mentorship, and time.

If companies stopped hiring juniors in 2024-2025, those absent juniors cannot become mid-level developers in 2028 or senior developers in 2033. The pipeline doesn't pause; it empties. And once emptied, it cannot be quickly refilled. You cannot hire experience that does not exist.

The industry is creating what researchers call a "self-inflicted talent drought". Without junior employees learning from senior ones and eventually replacing them, organisations risk hollowing out their own talent ecosystems. We have seen this pattern before. When companies offshored entry-level development work in the 2000s, they created a "missing middle" in domestic career development—a gap in the career ladder that persisted for years.

Matt Garman, CEO of AWS, pushed back hard on the idea of replacing entry-level developers with AI, calling it "one of the dumbest things I've ever heard."⁷ His question cuts to the heart of the problem: "How's that going to work when ten years in the future you have no one that has learned anything?"

The assumption driving these decisions is that AI will continue improving until it can handle all the work currently done by juniors, then mid-level developers, then perhaps seniors too. But this assumption ignores what junior developers actually do and why it matters.

Junior developers are not just cheap labour producing simple code. They are the learning ground for the entire profession. They ask naive questions that expose assumptions seniors have forgotten they made. They bring fresh perspectives uncorrupted by "we've always done it this way." They force senior developers to articulate knowledge that has become unconscious, making that knowledge transferable. They provide the redundancy that allows organisations to survive when senior developers leave.

When you eliminate junior positions, you don't just save salary costs. You lose the questioning, the fresh thinking, the knowledge formalisation, and the organisational resilience. You create a team of seniors who can maintain what exists but struggle to explain, document, or transfer their knowledge because they have no one to transfer it to.

The retirement cliff compounds the crisis

The junior developer extinction is occurring simultaneously with another demographic crisis: the retirement of experienced developers. Roughly 75 million Baby Boomers are expected to retire by 2030.⁸ In technology specifically, with the developer workforce heavily concentrated in the 25-34 age range, the experienced cohort is smaller than in many industries—and shrinking.

The COBOL situation offers a preview of our broader future. The typical COBOL programmer is now around 58-60 years old, with the vast majority expected to retire by 2030.⁹ Very few schools still teach COBOL, and many colleges have not taught it in their computer science departments since the 1980s. Yet 95% of ATM transactions and 70% of banking systems still run on COBOL. We are facing a knowledge cliff with no one to catch the falling expertise. The industry spent decades calling COBOL obsolete whilst continuing to depend on it. Now it scrambles to find anyone who can maintain the systems it refused to replace.

Research shows that 72% of managers across retail and manufacturing are not confident their companies can retain knowledge when experienced workers retire. The same dynamic applies to software development. When senior developers retire, they take with them decades of institutional knowledge—why that system was built that way, what happens if you change this configuration, which vendor promises to trust and which to ignore.

In healthy organisations, this knowledge transfer happens naturally. Senior developers mentor juniors, who become mid-level and take on more responsibility, who eventually become seniors themselves as the previous generation retires. The knowledge passes from generation to generation like an oral tradition.

But we have broken this tradition. We are simultaneously losing seniors to retirement and refusing to create new juniors. The result will be a catastrophic loss of institutional knowledge with no mechanism for replacement.

The AI productivity paradox

The cruel irony is that the AI tools supposedly replacing junior developers do not work as well as claimed, particularly for experienced developers working in familiar codebases.

A recent METR study found something remarkable: experienced developers using AI tools (Cursor Pro, Claude 3.5/3.7 Sonnet) on projects where they had an average of five years of prior experience were actually 19% slower than when working without AI.¹⁰ Before starting tasks, these developers forecast that AI would reduce completion time by 24%. After completing the study, they estimated AI had reduced time by 20%. The objective measurement showed the opposite—AI slowed them down.

This aligns with other findings about AI-generated code quality. Analysis of Fortune 50 companies found that AI-assisted developers produced three to four times more code but generated ten times more security issues.¹¹ GitClear's analysis of 211 million lines of code showed code clones rising from 8.3% to 12.3% whilst refactoring dropped from 25% to less than 10%.¹² We are generating more code of lower quality.

The joke that "two engineers can now create the tech debt of fifty" contains a grain of truth. AI amplifies productivity in generating code—including generating technical debt, security vulnerabilities, and maintenance nightmares. Without junior developers learning proper practices and senior developers having time to review and mentor, the code quality spiral will accelerate.

Even Andrej Karpathy, who popularised the term "vibe coding" for AI-assisted development, stepped back from his own creation.¹³ His latest project was entirely hand-coded. "I tried to use Claude/Codex agents a few times but they just didn't work well enough at all," he posted recently.¹⁴

Junior developers learning to debug often spend hours on issues that experienced developers solve in minutes. This apparent inefficiency is actually investment. The learning happens through struggle—forming hypotheses, reading stack traces, eliminating possibilities systematically. This develops debugging instincts that transcend any specific bug fix. That learning cannot be compressed into an AI prompt. It requires the struggle.

The hidden costs of short-term thinking

When companies eliminate junior developer positions, they typically calculate savings based on salary differential. A junior developer might cost 150,000. Replacing one senior's capacity with AI tools might cost $2,000 annually. The spreadsheet math looks compelling.

But this accounting ignores the full cost structure. Direct costs of not hiring juniors include future senior developer scarcity—by 2035, the supply of experienced developers will be drastically reduced, and those who exist will command premium salaries. Knowledge transfer failure means institutional knowledge leaving with retiring seniors cannot be replaced. The recruiting cost explosion is coming; when everyone needs seniors and no one has grown them, recruiting becomes a zero-sum competition that drives costs up for everyone.

Indirect costs compound the problem. Innovation capacity degrades because junior developers bring fresh perspectives and challenge assumptions; without them, organisations calcify. The quality spiral accelerates as AI-generated code reviewed only by overworked seniors accumulates technical debt faster than it can be addressed. Senior burnout rises as experienced developers take on more work without support, leading to higher turnover and further knowledge loss.

The organisations cutting junior positions are engaged in tragedy of the commons thinking. Each individual company benefits from not paying to train juniors whilst benefiting from the juniors trained by others. But when every company adopts this strategy, no juniors are trained, and the entire industry suffers. Everybody assumes somebody else will train the next generation. Everybody is wrong.

The choice ahead

The solution is not complicated, though implementing it requires rejecting short-term thinking. Companies must treat junior hiring as pipeline investment rather than cost centre elimination. Entry-level positions need to be maintained even when AI tools reduce immediate productivity needs. Knowledge transfer systems must be formalised before retiring seniors leave. And the industry collectively needs to recognise that training the next generation benefits everyone—including competitors.

The alternative is already visible. By 2035, we will face a severe shortage of senior developers, not because people stopped learning to code, but because we refused to let them start. The COBOL crisis will expand from legacy banking systems to modern web applications, mobile platforms, and cloud infrastructure. Knowledge will be lost not because it was never documented, but because no one remained to understand the documentation.

We are not watching AI replace human developers. We are watching an industry cannibalise its own future, one eliminated junior position at a time.