A couple of weeks ago, I was having a pretty interesting conversation with a friend about AI killing software development jobs.

This has become a hot topic in Silicon Valley, with some like Jensen Huang claiming that it’s no longer imperative for children to learn to program, while others like Patrick Moorhead offer a more historical perspective: “For over 30 years, I’ve heard ‘XYZ will kill coding’ yet we still don’t have enough programmers.”

Of course, many would argue that AI is fundamentally different from previous abstractions. Companies are investing billions in AI specifically to reduce costs and increase efficiency, not to create jobs.

However, I believe examining how abstraction layers have historically transformed programming offers valuable insight into what’s likely to happen. Each major advance in programming has been about creating new layers of abstraction, and rather than eliminating programming jobs, these abstractions have consistently expanded what’s possible and created new specializations.

Consider how each major transition in programming history represented a new abstraction layer:

Assembly Language is an abstraction over Machine Code (binary)

; Memory management in Assembly
mov ax, [1000h]  ; Direct memory access
add ax, 5
mov [1002h], ax

This evolved to C, where we started thinking in variables rather than memory addresses:

int x = 5;  // The memory address is abstracted away
int* ptr = malloc(sizeof(int));  // But we still manage memory
*ptr = 10;
free(ptr);

Then C++ introduced object-oriented abstractions while maintaining memory control:

class Vector {
int* data;
public:
Vector() { data = new int[100]; }
~Vector() { delete[] data; }  // Still explicit memory management
};

Python took us further, handling memory management automatically:

numbers = [1, 2, 3]  # Memory management is completely abstracted away
# No explicit cleanup needed

AI just represents the next major abstraction layer. Instead of telling the computer how to solve a problem step by step, we’re moving toward describing what we want to achieve:

# AI-assisted approach
# Prompt: "Sort this array efficiently"
# AI generates the implementation based on the intent

This represents more than just another abstraction layer, rather it’s a fundamental shift in how we express our intent to computers. While previous abstractions like Python automated memory management or C abstracted away machine code, AI aims to bridge the gap between human thinking and computer execution. Yet, just like how developers using Python still need to understand memory implications for performance critical applications, AI assisted development will require understanding of the underlying principles to effectively guide and validate the AI’s output.

None of these progressions ever eliminated the need for programmers. Instead, they changed the level at which most developers engage with computation. Just as Python developers still benefit from understanding memory management principles, future AI assisted developers will need to understand overarching programming concepts to effectively work with and control these new abstractions.

Each abstraction layer introduces its own drawbacks. Python’s automatic memory management came with performance costs. Object oriented programming added runtime overhead in exchange for organizational clarity.

Similarly, AI assisted programming, while bringing powerful capabilities, comes with trade offs in control, predictability, and resource usage.

Yet these trade offs have historically been worth it for most applications, enabling entirely new categories of solutions. When developers could stop worrying about memory management, they built larger, more complex applications.

When they could think in terms of objects and classes rather than memory layouts, they created massive collaborative software projects that would have been unmanageable before.

Each abstraction layer, while introducing its own challenges, dramatically expanded what was possible. The move from Assembly to C created an entire industry around compiler optimization and cross platform development. Experts were needed who understood both the high level language features and how they translated to efficient machine code.

Object oriented programming spawned new specializations in software architecture and design patterns problems that didn’t even exist in the procedural programming era. Python’s high level abstractions, while carrying performance costs, enabled rapid application development and data science applications that would have been impractical to build at lower levels.

While the emergence of new roles like prompt engineers and AI system architects seems promising, we should be clear eyed about the future.

Unlike previous advances that primarily abstracted away implementation details, AI aims to automate the decision making process itself. When critics ask what new jobs AI will create, answers often feel speculative at best.

However, software development presents a unique case. Unlike many other fields, it has consistently shown that abstracting away complexity doesn’t reduce the need for developers, it enables us to tackle more complex problems that weren’t feasible before.

Take modern web development: abstracting away assembly and memory management didn’t eliminate programming jobs; it enabled the creation of sophisticated applications that require even more developers working at higher levels of abstraction.

While base level programming is seemingly becoming more accessible, the problems we face are coincidentally getting more complex. Each abstraction layer enabled us to work at a higher level, but that just means we end up solving harder problems that weren’t feasible before, creating new jobs required to tackle those problems in the process.

The perpetual climbing of the abstraction ladder doesn’t reduce the need for skilled developers. If anything, it ends up multiplying it by opening up new possibilities and challenges at each level, each requiring new specialists to tackle them.

It’s worth noting that many of today’s most common programming jobs didn’t even exist 25 years ago. Mobile developers, cloud architects, DevOps engineers, machine learning specialists, these roles emerged because new abstractions allowed us to tackle entirely new categories of problems.

In 1999, trying to explain to a programmer what a “Kubernetes architect” or “prompt engineer” does would have been impossible, not just because the tools didn’t exist, but because the entire context these roles operate in hadn’t been invented yet.

Each wave of technological advancement has created job categories that would have been impossible to predict. Looking forward, AI likely won’t just automate existing jobs but enable entirely new categories of work we can’t even envision today.

The field of software development isn’t dying. Instead it’s evolving, just as it always has, creating new opportunities and specializations along the way. Those who put the effort to adapt to this evolution will do well while those who don’t are likely to fall behind and compete for a small cohort of legacy jobs, as we see with Assembly and C today.

Or so I would like to think.