What "Senior Engineer" Means in an AI-Native World

{% blog_post_wrapper %}In Part 1, I explored how AI is disrupting the traditional path to engineering expertise—the struggle, failure, and scar tissue that forged senior engineers for decades. The data shows companies have quietly stopped hiring juniors, creating a "hollowed-out career ladder" with no clear path from beginner to expert.

But doom-scrolling about the death of software careers misses the more interesting story: what comes next.

Junior developers aren't going extinct. Senior engineers aren't becoming obsolete. But both roles are metamorphosing into something we haven't seen before.

How Junior Developers Will Evolve (Not Disappear)

Junior developers will still exist. They will still be essential. But they will feel less like apprentice blacksmiths and more like product managers with technical superpowers, managing a fleet of AI assistants rather than hammering out code character by character.

The skill of "Can I turn this product request into working software" doesn't disappear. It shifts. Instead of spending 90% of your time typing semicolons and debugging syntax errors, you spend 90% of your time refining prompts, validating outputs, and understanding why the AI's suggestion does or doesn't fit your specific context.

This will absolutely frustrate the grumpy senior engineers. I can already hear them: "Kids these days can't write a for loop anymore. What is the world coming to?"

And they'll be right. Many of them won't be able to write a for loop from scratch—at least not with the speed and fluency that came from typing thousands of them by hand.

But here's the thing: if done well, they largely don't need to.

Just like I don't need to know x86 instruction sets to build valuable software. Just like I don't need to manage my own memory allocation. Just like I don't need to hand-optimize how my code compiles down to machine instructions. These skills didn't vanish from the earth—they became specialized, concentrated among the people who work on compilers and operating systems and embedded systems where every cycle counts.

The COBOL programmers are a perfect example. Universities stopped teaching COBOL decades ago. In the 1980s, students were being advised it was a "dead language," not worth studying. Yet COBOL still powers 70% of global business transactions. Banks, insurance companies, government agencies—they're all running on COBOL mainframes. The average COBOL programmer is around 60 years old, and salaries for those with the skills to maintain these systems run between $90,000 and $150,000, with modernization consultants commanding even more.

Did COBOL die? No. It became specialized. The skill shrank to a smaller pool of experts who are, in many ways, more valuable than ever precisely because no one else bothered to learn.

The same thing is happening with assembly language in embedded systems. The same thing will happen with deep code expertise in an AI-augmented world.

The Four Skills That Will Define Senior Engineers

So what changes?

The path from junior to senior changes. The definition of "senior" changes. But the need for experienced humans who understand software deeply doesn't disappear—it becomes more critical.

GitHub CEO Thomas Dohmke describes a progression he's seeing among AI-adopting developers. At the most advanced stage, developers "no longer write code, having delegated that task to AI agents, but focus on refining prompts and reviewing and validating the generated implementation." He calls this the "strategist" stage.

But notice what the strategist still needs: the ability to review and validate. To know when the AI is wrong. To recognize when a suggestion is inefficient, insecure, or simply doesn't fit the architecture. To understand why code works, not just that it works.

Satya Nadella revealed in April 2025 that 20-30% of Microsoft's code is now generated by AI. Google's Sundar Pichai reported similar numbers. Microsoft CTO Kevin Scott predicted that 95% of all code could be AI-generated by 2030.

But Nadella also offered a telling comparison. He likened the rise of AI to the emergence of electricity—and noted that it took around 50 years before factories learned how to fully leverage electrical power. "That requires software and also management change," he said. "Because in some sense, people have to work with it differently."

If I had to distill what "senior" will mean in this new world, it comes down to four capabilities:

Systems thinking: Understanding how components interact, where failures cascade, why certain architectures scale and others don't. This is hard to learn from AI because it requires understanding context that spans the entire stack.

Verification and judgment: The ability to look at AI-generated code and know whether it's correct, secure, performant, and maintainable. This requires exactly the kind of deep understanding that comes from having written (and debugged) similar code yourself.

Problem translation: Taking ambiguous business needs and turning them into precise specifications that AI can execute. This is surprisingly difficult. It requires understanding both the domain and the technical constraints.

Knowing when you're wrong: The humility to question AI's confident answers. The experience to recognize when something feels off even if you can't immediately explain why. This is the accumulated scar tissue that senior engineers carry—and it's the hardest thing to develop without making your own mistakes.

Why the Software Industry Will Grow, Not Shrink

Atlassian CEO Mike Cannon-Brookes, when asked if AI would mean fewer developers in five years, was emphatic: "No, I don't think so. I think there'll be far more, and far more people creating software in other functions, whether they're in finance or HR or marketing. There's going to be a lot more people creating software."

This matches the pattern from every previous abstraction layer. When the cost and effort of creating something drops, more people create more things. We don't have fewer writers because of word processors. We don't have fewer photographers because of smartphones. We have vastly more of both—and the professionals who remain are doing different, often more sophisticated work.

The software industry will likely follow the same pattern. More software created by more people. A smaller but highly valued pool of specialists who deeply understand the underlying mechanics. And a new category of technical professional who sits between "vibe coder" and "systems architect"—people who can translate business needs into working software by orchestrating AI tools, validating outputs, and knowing when to call in the specialists.

Linus Torvalds, ever the pragmatist, put it this way: "I think vibe coding may be a horrible, horrible idea from a maintenance standpoint if you actually try to make a product from it, but I think it's a great way for new people to get involved and get excited about computers."

Getting people involved and excited about computers. That's not nothing. That's how many of us started—before we knew what a compiler was, before we understood memory management, before we could explain Big O notation. We were excited, and we figured out the rest.

The kids who can't write a for loop today might be the architects of tomorrow's systems—not despite their AI-native education, but because of it. They'll have spent their formative years learning to ask the right questions, validate complex outputs, and think in terms of systems rather than syntax.

Or they might end up lost, lacking the foundational understanding to recognize when AI is confidently wrong. That's a real risk.

Navigating the Transition: A Framework for Engineering Leaders

I don't have a tidy conclusion here because we're living in the middle of the story.

The industry as we know it will change, but it will not disappear. Software provides enormous value to enormous numbers of people. That value doesn't evaporate because the tools for creating it got better. If anything, it expands—into domains and use cases that were previously too expensive or complex to address.

What we're doing is reinventing what it means to build and maintain software. The skills that defined "senior engineer" for the past 30 years—fluency in syntax, ability to write complex algorithms from scratch, deep familiarity with specific languages and frameworks—will become less universal and more specialized. The skills that will define senior engineers for the next 30 years are still emerging.

Torvalds, who has navigated more technological transitions than almost anyone, offered this assessment of AI: "90% marketing, 10% reality." But he also acknowledged that in five years, we'll see what AI is actually useful for. The hype will settle. The real applications will emerge. And we'll adapt, as we always have.

The craft of software development is not dying. It's metamorphosing. The programmers who understand both the new abstractions and the old foundations—who can work with AI and also understand what it's actually doing—will be the ones who thrive.

The ones who rely entirely on AI without understanding what's happening beneath the surface? They'll build fragile systems that work until they don't, and they'll lack the skills to debug them when they fail.

The ones who refuse to engage with AI at all? They'll write beautiful, hand-crafted code that nobody wants to pay for, because their competitors are shipping ten times faster.

The path forward is somewhere in the middle—embracing the leverage that AI provides while continuing to develop the deep understanding that makes that leverage meaningful.

We're figuring this out together. We don't know exactly what the next step will be. But we have the evidence of what has come before: every major abstraction layer was met with fear, followed by adaptation, followed by an expansion of what was possible.

There's no reason to believe this time will be fundamentally different.

Just different enough to be interesting.

Jeremy Freeman is the CTO of Allstacks. He spends his time thinking about how engineering teams can navigate technological transitions without losing what makes them effective.{% end_blog_post_wrapper %}