Alan Turing asked the question that started all of this: can machines think? In 1950 he imagined a machine you could talk to and not be able to tell apart from a person. He argued there was no good reason to believe it impossible.
Seventy-five years later the machine arrived. And the first person it came for was the one closest to it.
There's a clean irony in that. Of all the jobs people said AI would touch, software engineering was supposed to be safe. Too technical, too specialised, too human. Instead it's near the front of the line. Large language models turned out to be freakishly good at exactly the thing engineers were paid for: turning intent into working code. The people who built the thinking machine are the ones now competing with the thinking.
So let me say the uncomfortable thing plainly: the software engineer, as we knew him, is dead. And we killed him. Not the machine. Us. Developers. We built the tools, we adopted them, we redefined our own job out from under ourselves.
Now look around. A lot of engineers got fired over the last two years. A lot of the same companies are quietly hiring engineers again. And the ones who stayed are shipping more than they ever have. All three things are true at once. So what's actually happening?
This isn't an extinction. It's a reshuffle. The word "engineer" survived; the definition underneath it didn't. What you had to be three years ago and what you have to be now are not the same job wearing the same title.
The engineer we used to want
Three years ago, this was the person every founder wanted to land.
- Rolls in at 11:30.
- Drinks twelve coffees a day.
- Speaks to almost no-one.
- Has been coding since he was twelve.
- Writes clean, elegant code and is quietly obsessive about it.
We loved this person. We built teams around protecting him. No meetings, no clients, nothing that wasn't the code. His output was the product, and everything else was noise to be filtered out.
That instinct made sense when writing the code was the hard, scarce, expensive part. Protect the bottleneck.
The code is no longer the bottleneck.
The assumption now is that anyone can write code. I'd put it more carefully: anyone can produce code. Getting a working function out of a machine is trivial. Standing up a production-grade system that doesn't fall over is still hard, and still rare. So the scarcity didn't vanish. It moved. Which raises the real question: if code is still complex, is the engineer actually dead, or just standing somewhere else?
The engineer we need now
We built artificial intelligence, and the result is that we now need engineers to be more human.
When a machine can produce the code, the value stops living in the typing. It moves to everything around it, the judgment the machine doesn't have. Which problem is worth solving. Whether the output is actually correct. What the business is really trying to do underneath the ticket. The stuff that requires understanding people, not just syntax.
So the new engineer looks different:
- Understands the business, not just the stack. Knows why the feature exists, which means knowing when to push back on it.
- Thinks about design and the person on the other end, not only the implementation.
- Communicates. Reads the room. Understands a little marketing, a little economics, the world the software is actually for.
- Dares. Ships. Makes a call with incomplete information instead of waiting for a perfect spec.
- Reads what the machine produced and knows, on sight, when it's wrong.
None of that is a downgrade. It's a harder job than the one before it. The old role rewarded depth in one narrow place. The new one rewards judgment across the whole system, and judgment is the one thing we haven't figured out how to automate.
To be precise about what changed: the old engineer sat in the middle. Someone described what should exist, he turned it into working code, someone checked the result. That middle, the execution, is what got automated. What's left are the two ends. Specifying: saying exactly what should exist, and why. And answering for it: being the person who stands behind the result when it ships.
Execution got cheap. Specification and answerability got scarce. That's the new job.
You can see it in the price. The most valuable engineers right now are the ones who sit with a customer, understand the problem, and build against it. They cost a fortune, because almost nobody has all of those skills in one head. We automated the cheap part and made the human part more expensive.
The problem this hands to companies
Everyone frames this as bad news for engineers. It isn't. The engineers will adapt. The good ones already have.
The harder problem lands on the companies.
You're being asked to adopt this shift fast, because your competitors are. But you can't rush it. If you tear through the transition carelessly you throw out the processes that actually work: the review gates, the standards, the institutional knowledge that kept your systems standing. Move too slow and you're left behind. Move too fast and you break the thing you were trying to protect.
And the definition of the person you're hiring changed underneath you. You're still writing job specs for the old engineer while the work quietly became something else. The first rungs to disappear are the junior ones, the exact ladder your seniors climbed. Most companies haven't caught up to what they're actually looking for, or how they'll grow it.
So the real death here isn't the engineer. It's the old idea of what an engineering organisation is: a room full of people protected from the business, shipping code. That version is gone.
If you lead a team, the question isn't "how do I replace engineers with AI." It's sharper than that: what am I still hiring for that the machine made cheap, and how do I build the judgment I can no longer buy off the shelf?
I wrote the full argument, with the evidence, in The Principal Firm. Leave your email at jochemverheul.com and I'll send it over.
My name is Jochem.