(A reflection on AI-generated code and the history of software development)
In the last couple of years, many developers have started saying something like:
“AI will replace programming.”
Personally, I don’t think that’s what’s happening.
What we’re seeing looks much more familiar.
It’s just another layer of abstraction.
The History of Programming Is the History of Abstraction
If you look at the evolution of computer science, it’s essentially a story about building layers.
At the beginning we had to write:
- machine code
- assembly
- low-level languages
Then came higher-level languages.
Then frameworks.
Then platforms.
Every step moved us further away from the machine while making software easier to build.
Compilers, interpreters, and APIs all did the same thing: they allowed developers to work at a higher conceptual level while the system handled the complexity underneath.
Now something similar is happening again.
LLMs as a New Interface
Large Language Models introduce something interesting:
natural language as an interface to software creation.
Instead of writing:
- syntax
- configuration
- boilerplate
we can increasingly describe intent.
You explain the idea, and the system generates the code.
In this sense, LLMs behave almost like a new kind of compiler.
Not a compiler from C to assembly.
But something closer to:
intent → implementation
But Abstractions Are Never Perfect
There’s an old meme that says:
“If your code doesn’t work, blame the compiler.”
It’s funny, but it also reveals something important.
Abstractions don’t remove complexity.
They move it somewhere else.
Every developer knows this moment:
You’re happily using a framework…
until something breaks.
And suddenly you have to understand the internals.
The abstraction leaks.
This isn’t a flaw of abstraction — it’s simply how complex systems work.
The Skill That Never Changes
Because of this, one thing in programming never really disappears.
The ability to look below the abstraction layer.
It doesn’t matter if that layer is:
- a framework
- a compiler
- a runtime
- or now an LLM
Eventually something breaks.
And when it does, someone needs to understand what’s happening underneath.
AI Doesn’t Replace Engineers
If anything, AI might make this skill even more important.
Because the higher the abstraction, the more critical it becomes to understand:
- when to trust the system
- when to inspect the output
- when to go deeper.
LLMs might generate code.
But understanding systems is still a human responsibility.
Final Thought
AI-generated code is not the end of programming.
It’s simply the next chapter in a very long story.
A story about abstraction, tools, and the evolving relationship between humans and machines.
And like every abstraction before it,
it will make some things easier…
while making other things more interesting.
Top comments (0)