The analogy I keep coming back to is the manual transmission.
There was a time when knowing how to drive stick was not a niche preference. It was part of the skill. Race car drivers knew it. Mechanics knew it. Regular drivers knew it. The gearbox was a physical relationship with the machine: clutch, torque, timing, resistance, control.
And then automatics arrived.
The Resistance Is Older Than the Technology
At first, the purists hated them. Some of that criticism was valid. Early automatics were sluggish, inefficient, and disconnected from the feel of the car. But some of the resistance was something else. If you have spent years mastering one interface, it is easy to confuse the interface with the craft.
My father hated automatics in the early years. Part of it was performance. But part of it was repairability. He could work on a manual transmission. An automatic was opaque. It took control away from the person who understood the machine.
That argument sounds familiar now.
A lot of programmers resisting AI are making a version of the same complaint. They do not trust the output. They cannot repair what the system generates. They believe real programmers need to understand every gear, every linkage, every mechanical step between intent and motion.
And they are not entirely wrong… the data is on their side, for now.
Stack Overflow’s 2025 developer survey found that 84% of developers now use or plan to use AI tools1, and 51% of professionals use them every single day. In the same survey, trust in those tools fell to its lowest point on record: only 29% of developers said they trust the output2, down eleven points in a year, and 45% said debugging AI-generated code eats their time3.
That is not a contradiction. That is a transition.
Adoption climbing while trust falls is not a sign the technology failed. It is the exact signature of the early automatic: good enough to take over before it was good enough to love.
The Market Moves Anyway
By the late 1990s, automatic transmissions had improved enough that most of the old complaints stopped mattering for most drivers. They got faster, smoother, more reliable, better suited to how people actually drove. Paddle shifters appeared, partly as a concession to the driver who still wanted the feeling of control. But the market had already decided.4
The numbers are blunt. In 1980, just under 35% of new American cars came with a manual. By model year 2021 it had fallen below one percent5, where the EPA reports6 it has stayed ever since.
People did not buy automatics because they were lazy. They bought them because stop-and-go traffic made the clutch a tax instead of a pleasure. They bought them because the rest of the car had grown too complex to repair in a home garage anyway. The whole system had moved past the era when one person could hold every linkage in their head.
And it moved unevenly. Europe held the line far longer… 89% of new cars there were manual in 2000, and stick shifts were still roughly a third of new sales as late as 2022, according to JATO Dynamics7. Transitions are not instant. They are not uniform. But the direction does not reverse.
That is where programming is now.
The Ladder Doesn’t Stop
Here is the part most people miss, and it is the part that matters.
The automatic transmission did not just replace the clutch. It was the first rung on a ladder. Once the machine could manage its own power delivery, the human’s hands came off the gearbox. Then cruise control took the feet off the pedals. Then lane-keeping took the eyes off the lane. Then autonomy takes the attention off the road entirely.
Each step abstracted away one more layer of control. And each step moved the human in the same direction… away from operating the machine, toward simply stating intent. Take me downtown.
That is moving up the stack. Not in one leap, and not for any single driver who only felt himself doing less in 1995. It happened at the level of the whole system, across decades. The automatic was rung one.
You can argue about which rung was load-bearing. The torque-converter automatic was not the only precondition for self-driving… electric drivetrains abstracted the transmission away even more completely, with no gears at all, and that is the substrate autonomy is built on now. But the part is not the point. The pattern is. Every abstraction of mechanical control was a step toward the human who only says where to go.
That is where programming is now.
The Driver Was the Crash
There is a harder fact underneath all of this, and it changes what the purist is defending.
Removing the driver did not just relocate the human. It saved lives.
Through December 2025, Waymo had driven more than 170 million miles with no one behind the wheel. Compared to human drivers on the same roads, its cars were involved in 92% fewer crashes causing serious injury or worse, 83% fewer crashes severe enough to deploy an airbag, and 82% fewer injury crashes of any kind8. Fewer pedestrians struck. Fewer cyclists. Fewer motorcyclists. In the serious-injury category the gap was roughly an order of magnitude — not a little safer, categorically safer.
This is not a happy accident of the technology. It is the mechanism.
Federal crash data has for years put the critical reason in the overwhelming majority of crashes, about 94%9, in NHTSA’s accounting, on the human driver. The human was not riding alongside the failure mode. The human was the failure mode. Take the human out of the loop and you take out the error.10
Now go back to my father and the gearbox.
What was he actually protecting? He said repairability. He said control. But the thing he wanted control of was the thing that, in aggregate, caused the wreck. The craft he defended was real as craft. It was not real as safety. When he kept his hands on the machine, he was protecting his relationship to the machine, his identity as the man who understood it, and calling it something nobler.
That is the question every developer resisting AI has to answer honestly.
When you insist on writing and understanding every line, what are you protecting? The quality of the work or your relationship to the machine?
The Orchestrator Is the Paddle Shifter
So the programmer moves up the stack. Where does the ladder stop?
If the driving arc holds all the way, the endpoint is the passenger in the robotaxi — who inspects nothing, detects no failure modes, orchestrates nothing, and is statistically safer for it. Which means the developer who inspects the output and orchestrates the system, the role it is tempting to call the future, is not the destination. It is the paddle shifter: a concession bolted onto a machine that is learning not to need it.
I will not soft-pedal the part that cuts the other way.
The verdict on software is not in yet. Driving has a clean metric and a settled result — crashes per mile, and the machine wins. Code has no 92% number. Right now the opposite is closer to true: in that same survey, nearly half of developers said debugging AI-generated code costs them time, and trust sits at a record low. Today, the developer who reads the diff and catches the failure mode is earning the seat. The machine is not yet safer than the human at the level of the whole system.
But notice what that is. It is the early automatic again. Sluggish, untrusted, not yet good enough to love. Same shape, earlier on the curve.
And the curve has a turn in it that driving already took. There is a point, not today, but visible from here, where the machine becomes measurably more reliable than the hand. Past that point, keeping the human in the loop stops being diligence. It becomes the new failure mode… the same way a human grabbing the wheel back from a safer autonomous system makes things worse on average. The inspector who insists on touching every output will, eventually, be the one introducing the defects.
The paddle shifter is not just nostalgia. Held too long, it is the hand on the wheel that should not be there.
Builder or Passenger
The programmer is not disappearing. But moving up the stack is not a promotion everyone receives. It is a fork.
One road leads to the few who define the systems, constrain them, and own how they fail… the people who build the autonomy. The other leads to everyone who states intent and trusts the output, the way you trust a robotaxi to brake, and increasingly are right to.
The automatic did not make better drivers. It made driving disappear into a larger task, and then it kept going, rung after rung, until the driver was a passenger who was safer for letting go. AI will not make better typists. It will make typing disappear — and the day it makes software measurably more reliable than the hand that used to write it, the purist will face the same question my father did.
Not “can I still repair it?”
But “what was I really protecting?”
The mechanic who only knew the gearbox lost something real. The engineer who understood the whole system is the one the next machine gets built around. The driver who would not let go became, in the end, the most dangerous thing on the road.
The stack is moving. Decide which end of it you intend to be on… before the machine decides the hand in the loop is the problem.