LLMs have created a new programming language. It just happens to be the language you already use.
This follows the same pattern as Python, C, and Assembly. Each abstraction eliminated knowledge requirements and expanded who could code.
The result is always the same: fewer engineers by the old definition, more engineers overall.
It’s happening again.
LLMs Created a New Programming Language
The new programming language is English.
That’s it. You describe what you want in plain language, and the LLM writes the code.
This isn’t a new phenomenon. It’s a recurring pattern in software engineering. Every major abstraction layer did the exact same thing.
The pattern: each new abstraction hides complexity, drops the skill floor, and expands who qualifies as an “engineer.”
Python did it. C did it. Assembly did it.
LLMs are doing it now.
Python, C, and Assembly Did the Same Thing
Python removed the need to know pointers and memory management. You don’t need to think about stack vs heap. You don’t manually allocate and free memory. The language handles it.
C removed the need to know assembly language. You write functions and loops, not MOV and JMP instructions. The compiler translates.
Assembly removed the need to know binary. You use mnemonics instead of raw opcodes. The assembler handles the rest.
Each abstraction is a layer that hides how the computer actually works.
The easier it is to write, the faster you can learn it. The faster you can learn it, the more people can do it.
The total addressable market of engineers explodes.
What Happened Each Era: Less “Real” Engineers, More Total Engineers
I went to 4 years of engineering school. I learned everything from silicon to software.
Logic gates. Circuit design. Memory allocation. Assembly language. Compiler theory. The full stack, all the way down.
Most of that knowledge? Not needed anymore.
Most engineers today don’t know assembly. They don’t know how memory management works under the hood. They don’t know logic gates or circuit design.
And that’s okay.
Python engineers don’t need to know C. C engineers don’t need to know assembly. Assembly engineers don’t need to know binary.
It’s not very useful knowledge for a vast majority of use cases.
It’s also easy to see that writing in Python is lightyears faster than C or Assembly, thereby more productive.
As a result, demand for “traditional” engineers by yesterday’s definition decreases.
Replaced by exploding demand for those who have the new skill set.
Each time the old definition became obsolete, demand for the new definition expands the total.
The pattern: fewer engineers by the old standard, exponentially more by the new standard.
What Software Engineering Becomes
So what does this mean for software engineers?
The definition of software engineer will change. Again.
Most engineers today don’t match the definition from 20 years ago.
Ask any engineer on your team:
- Do you rack your own servers or hit “deploy” on Vercel?
- Have you ever dealt with a segmentation fault?
- Have you ever written assembly to optimize performance?
The vast majority will say no.
By the definition of a “real engineer” from yesterday’s standards, most engineers today don’t qualify. They’re using abstractions that hide all of that.
That’s the pattern repeating.
There will be fewer “real” software engineers by today’s definition.
But there will be more total software engineers overall.
The definition will simply shift. Engineers will start to look more like PMs, designers, and domain experts — not traditional computer science graduates.
The hiring question that shows this shift:
You’re building a sales outbound tool. Do you hire a sales expert or an engineer?
Right now, the answer is vague. You hire an engineer, PM, and salesperson to work together to build something useful.
But as LLMs make it easier to code, the calculus flips.
It becomes faster to teach a salesperson to code than to teach an engineer domain knowledge.
Domain knowledge becomes the scarce resource. Code becomes the commodity.
The new engineer: domain expert who can ship software.
Computer science fundamentals — compilers, memory management, algorithm optimization — get reserved for truly complex, innovative work. The stuff LLMs can’t handle yet.
Everything else? Domain experts with enough code to ship.
Both claims are true.
There will be fewer engineers by today’s definition. Just like there are fewer assembly programmers now.
And there will be more people writing code overall. Just like Python expanded the total number of engineers compared to C.
The definition is shifting toward domain experts who code.
If you define “engineer” as someone who knows compilers and memory management, there are already fewer (at least proportionally).
If you define it as “anyone who ships code,” there will be exponentially more.
The pattern repeats.
Caveats & Clarifications:
- I make the claim several times there are ‘fewer’ engineers by older definitions. This is not 100% true. A more accurate statement is ‘demand for those roles has decreased’ and ‘the proportion of engineers who fill those roles reduced overtime’. In essence, there are ‘less of them’ compared to the total pie of engineering roles.
- I make the claim of being a ‘real’ engineer to be provocative. I don’t believe there exists a true definition. If there is, then it’s vague and unproductive topic to argue. I simply make the claim that the era of engineers from the 90s would likely make similar claims as the engineers of today. Both arguing that the new generation are not ‘real’ engineers. Assembly and kernel engineers could make the same argument about today’s general engineering population that today’s population is making about vibe coders. In reality, using AI to program is just the same as using Python - they’re just abstraction layers. Meanwhile, very few understand how their abstraction layer ultimately translates into the actual binary that runs on the computer. Everyone is just using different layers of abstraction.