The 1950s: The First “Death of Programmers”
In the earliest days of computing, programming meant writing machine code. Not high-level languages. Not frameworks. Not abstractions layered on top of abstractions. Actual machine instructions - manipulating registers, memory locations and binary opcodes directly.
It was highly specialised work, carried out by small groups of experts. Programming was closer to mathematics than to what we would now recognise as software development.
Then the compiler arrived.
With FORTRAN in the late 1950s, developers could write instructions that resembled human logic rather than hardware control. A machine translated those instructions into executable form. If you were a machine-code purist at the time, this looked like the beginning of the end. A machine was now doing the translation work that had defined your craft. Abstraction was diluting the discipline.
And yet the opposite of collapse happened. Software output expanded. Systems became more ambitious. The number of programmers increased rather than decreased.
The compiler did not eliminate programmers. It eliminated manual translation. The role shifted upward.
The 1990s: The “Death of Real Engineers”
A few decades later, the same pattern repeated itself.
Languages such as C and C++ required developers to manage memory explicitly. You allocated it, freed it, avoided leaks and prevented corruption. It was technical, error-prone and, for many, a mark of seriousness. Mastery of memory management separated “real engineers” from the rest.
Then managed runtimes emerged. Java and C# introduced garbage collection as a default expectation rather than an optional feature. Memory management became automated.
Again, there were warnings. Developers would lose control. Performance would suffer. Standards would decline.
Instead, whole classes of bugs largely disappeared. Larger systems became feasible. Engineers spent less time worrying about pointer arithmetic and more time thinking about architecture, design and scale.
Memory management did not vanish. It moved down the stack. The abstraction layer thickened, and the role moved up.
The 2000s: The “Death of Real Builders”
By the early 2000s, another transition was underway. Fewer teams were writing networking stacks, rendering engines or authentication frameworks from scratch. Instead, they were importing them. React components, mobile SDKs, REST APIs and cloud services became building blocks.
Software development shifted from construction to composition.
This, too, attracted criticism. Developers were no longer “building”; they were merely gluing together libraries. But that glue built global platforms. The reduction in low-level effort did not reduce system complexity; it increased it at a higher layer. The cognitive load moved upward, from implementation detail to system orchestration.
Each abstraction layer reduced friction at the bottom and expanded ambition at the top. And with every transition, the number of engineers grew.
The 2020s: The “Death of Coders”
Now there is a view that this time is different. If AI agents can generate most of the code, the argument goes, software engineers will disappear. If machines can translate requirements into working systems, what remains for humans to do?
There is truth in the premise. AI tools are increasingly capable of generating boilerplate, refactoring large codebases, writing tests and now scaffolding entire applications from a description. The productivity gains are real and accelerating. AI is highly likely to write most code in the future.
But we have seen this pattern before. The compiler translated high-level language into machine instructions. Garbage collectors abstracted memory discipline. Frameworks abstracted infrastructure. AI agents abstract implementation itself. They translate human intent into structured code.
This is not a break from history. It is a continuation of it.
What Disappears - and What Does Not
When abstraction arrives, something always disappears. Manual machine coding largely disappeared. Routine memory management diminished. Custom infrastructure builds gave way to frameworks. Jeff Bezos described the pattern well:
“There’s a lot of undifferentiated heavy lifting that stands between your idea and that success… 70% of your time, energy, and dollars go into the undifferentiated heavy lifting and only 30% of your energy, time, and dollars gets to go into the core kernel of your idea.”3
Now, repetitive coding and mechanical translation are being automated.
What will vanish is the work that is primarily syntactic and repetitive - the scaffolding, the boilerplate, the predictable patterns that can be inferred from context.
What does not vanish is judgment. Trade-offs do not disappear. Architectural decisions do not become irrelevant. Security constraints, performance considerations and economic accountability do not dissolve because a model can generate code.
The domain of responsibility moves upward. The human remains accountable for the system as a whole.
The Engineer as System Director
If AI agents increasingly write the first draft of software, the engineer’s role becomes less about syntax and more about intent. Less about implementation detail and more about constraint definition. Less about typing code and more about deciding what should exist at all.
The engineer becomes the director of systems rather than the drafter of functions. The job shifts toward architecture, validation, risk management and alignment with product goals. The abstraction ladder rises again, and those who climb it remain relevant.
Why Efficiency Expands the Profession
There is a belief that if software becomes cheaper to produce, fewer engineers will be needed. History suggests the opposite.
High-level languages lowered the barrier to entry, and more programmers emerged. The web expanded digital surfaces, and more programmers were required. Mobile multiplied touchpoints, and more programmers were needed. Cloud computing reduced infrastructure friction, and still the number of engineers grew.
As the cost of building software falls, more industries digitise. More processes are automated. More systems interconnect. The surface area of software increases faster than efficiency improves.
Wrapping Up
AI coding agents feel revolutionary because they operate at the visible layer of the craft - the act of writing code itself. But abstraction has been steadily removing visible layers for 70 years.
Machine code gave way to compilers. Manual memory gave way to managed runtimes. Custom infrastructure gave way to frameworks. Now implementation detail gives way to intent-driven generation.
Each time, a lower layer is automated. Each time, the human role shifts upward. Each time, the industry expands. Abstraction has always won. There is little reason to believe it will not win again.