Why AI won’t replace engineers, but will move the job up a level
AI agents are like affordable cars. Suddenly, almost anyone can “drive”. The question is not “Can you drive?”, but “Do you know where to go, why, and what to do when something breaks?”
This post started, like many things do these days, with me trying to argue on the internet.
I wanted to say that we are living through a coachman → chauffeur moment. It sounded clever enough at first. Skilled human operators are being replaced by a new machine. Nice analogy. Post the take. Collect the dopamine.
Then I realized I had it backwards.
We are not the coachmen.
We are the chauffeurs.
And AI agents are the mass-produced cars.
That framing feels much closer to what is actually happening in software development right now.
Before cars, moving from A to B required a professional. Then cars became affordable and usable enough that far more people could drive themselves. Society did not stop needing people who understood transportation. It changed who could participate, what counted as skill, and where the real value moved.
That is what AI is doing to software.
More People Will Build
The most obvious change is not that developers disappear. It is that many more people will be able to build software without being developers in the old sense.
That sentence still makes some engineers uncomfortable, but I think it is just true.
The cost of operating the machine is collapsing. You no longer need to know every mechanical detail just to get something moving. If you can describe a problem clearly, evaluate what comes back, and keep iterating, you can get surprisingly far.
A lot of software that never would have existed before will now be built by people who would previously have stopped at the idea stage. Not because they suddenly learned computer science, but because the interface to software creation is becoming cheaper and more human.
That is the real shift.
It is not “AI can code.” We already know that.
It is “software production is becoming accessible to a much larger group of people.”
Just like driving did not eliminate transportation experts, this will not eliminate software experts. But it will absolutely change the baseline expectation of who gets to participate.
So What Happens to Developers?
I do not buy the lazy version of “AI will replace developers.”
What I do buy is that it will change the job hard enough that some people will not recognize it anymore.
A lot of the work moves up a level.
Less manual implementation.
More steering.
More review.
More debugging.
More integration.
More judgment.
That already feels familiar to me. More and more often, I am not sitting there crafting every line by hand. I am describing what I want, testing what came back, noticing where it is wrong, and pushing it toward the result. When the AI gets stuck on a race condition, a bad migration, a broken OAuth flow, or some deeply annoying integration edge case, that is where engineering experience suddenly matters a lot again.
The skill did not disappear. It moved.
You still want someone in the room who understands the machine when the road gets messy.
That is why I think the “vibe coding” discourse misses the point a bit. The interesting question is not whether someone typed the code manually. The interesting question is whether they understand the system well enough to direct it, correct it, and take responsibility for the result.
A chauffeur is still not the engine.
But a chauffeur understands the machine, the route, the risks, and what to do when something goes wrong.
Cars Did Not Only Bring Freedom
This is where I think the analogy becomes even more useful.
Mass adoption of cars did not only bring convenience and freedom. It also brought congestion, pollution, road deaths, ugly cities built around parking lots, and entire industries lobbying to shape society around their product.
That part matters too.
If AI agents are the mass-produced cars of software, then we should expect the same pattern: not just democratization, but externalities.
We will get more software, yes.
We will also get more broken software, more low-quality software, more security disasters, more abandoned software, more opaque systems that nobody fully understands, and more products built by people who were able to ship before they were able to maintain.
We will also get more dependency on the companies that own the best models, the best platforms, the best distribution, and eventually the political leverage to define what “safe”, “responsible”, or even “normal” software development should look like.
That is the part people still talk about much less than they should.
The car industry did not simply sell cars. It eventually shaped roads, cities, regulation, advertising, culture, and public expectations. It lobbied aggressively. It trained society to organize itself around the machine.
It would be naive to think AI companies will behave very differently once enough of the economy depends on them.
The future risk is not just bad code from amateurs.
It is also concentrated power from oligopolies deciding how software gets built, which tools are allowed, which workflows are blessed, and which kinds of engineering become marginal.
Manual Coding Will Become a Cultural Marker
There is also a smaller and slightly funnier part of this shift.
It is probably only a matter of time before Dario or someone else starts using a word like “jaycoding” for people who still craft their code manually, as if writing software directly becomes some artisanal habit for people who refuse to move on.
I am only half joking.
Once enough people can produce working software through agents, manual coding stops being the default and starts becoming a specialized preference. Maybe a respected one, maybe a mocked one, maybe both.
We already do this in other fields. There is nothing strange about saying that one person uses industrial machinery while another still does part of the work by hand. Sometimes the manual version is better. Sometimes it is slower. Sometimes it is vanity. Sometimes it is craftsmanship. Usually it depends on context.
I expect software to end up in the same place.
There will still be engineers who want full control and write things themselves because it is the right tool for the job. There will also be people who treat manual coding as unnecessary nostalgia. And there will be a much larger middle group moving back and forth between both worlds depending on stakes, speed, and complexity.
The Job Is Not Going Away. It Is Moving.
That is why I keep coming back to the chauffeur.
The chauffeur still matters after cars appear. In some cases, less often than before. In other cases, much more than before. Especially when the road is dangerous, the passenger is important, the route is unusual, or the machine is expensive enough that mistakes matter.
That feels very close to where software is heading.
Yes, many more people will build.
Yes, the average cost of making software will keep falling.
Yes, a lot of programming work will become less manual and more supervisory.
And yes, some of the old prestige of “I personally wrote every line” will probably disappear outside the places where it truly matters.
But that does not make engineering irrelevant.
If anything, it makes good engineering more leveraged and bad engineering more dangerous.
When everything works, more people can drive.
When the road gets messy, the professionals still matter.
I did not stop being an engineer.
The job just moved up a level.