Every time a machine learns a new trick, skilled people panic. And every time, they say some version of the same thing: this is different. This time it’s really the end.
They’re always right that it’s different. And they’re almost always wrong that it’s the end.
I’ve been preparing a talk for Meeting C++ about what happened to the joy of programming in the age of AI. As part of that work, I went looking for historical parallels — moments when a tool threatened to automate away a craft. What I found was surprisingly reassuring. Not because the disruptions were painless, but because the pattern is so consistent that it starts to look like a law.
The craft doesn’t die. It moves.
“From today, painting is dead!”
When the daguerreotype was introduced in 1839, the French painter Paul Delaroche reportedly declared: *“From today, painting is dead!”- The camera could capture reality with a precision that no human hand could match. Portrait painters, landscape artists, anyone whose livelihood depended on faithful reproduction — they had every reason to be terrified.
And some of those livelihoods did disappear. Portrait miniatures, once a thriving craft, essentially vanished within a generation. The market for realistic commissioned portraits shrank dramatically. If you were a painter whose entire skill was accurate depiction of what the eye sees, the camera was indeed the end.
But painting didn’t die. It exploded.
Freed from the obligation to reproduce reality, painters went somewhere cameras couldn’t follow. Impressionism emerged just a few decades after commercial photography took hold. Then Post-Impressionism. Cubism. Surrealism. Abstract Expressionism. Each movement explored aspects of vision, emotion, and meaning that a mechanical lens simply could not capture.
As James McNeill Whistler put it: “The imitator is a poor kind of creature. If the man who paints only the tree, or the flower, or other surface he sees before him were an artist, the king of artists would be the photographer.”
The painters who thrived weren’t the ones who could reproduce reality most faithfully. They were the ones who had something to say about reality. The skill moved up — from execution to vision.
The priesthood of the machine
A century later, a remarkably similar panic played out in computing.
In the early 1950s, programming meant writing machine code by hand. Rows of zeros and ones, painstakingly arranged. John Backus, who worked at IBM at the time, later described the process as “hand-to-hand combat with the machine.” The programmers who could do this well formed what Backus called a priesthood — an elite group accustomed to coding around the obscure oddities of early hardware and fitting code into incredibly small memories. Efficient programming was considered a “black art” that could hardly be automated.
Then Backus proposed FORTRAN.
The idea was simple but heretical: let the programmer write in something resembling mathematical notation, and let the machine translate it into machine code automatically. A compiler.
The resistance was fierce. Jean Sammet, who documented the era in her 1969 book Programming Languages: History and Fundamentals, described it plainly: customers raised many objections, but “foremost among them was that the compiler probably could not turn out object code as good as their best programmers.”
Does that sound familiar? The machine can’t possibly produce work as good as a skilled human. It’s the same objection, wearing different clothes.
And initially, they had a point. Early compilers were inefficient. The generated code was slow. But Backus’s team built the first optimising compiler, and within a year of FORTRAN’s 1957 release, over half of all code running on IBM computers was generated by the FORTRAN compiler. The priesthood’s monopoly was over.
But here’s the crucial part: the priesthood didn’t vanish. Programming didn’t become trivial. What happened instead was that the craft moved up. Instead of obsessing over register allocation and memory layout, programmers could think about algorithms. About data structures. About architecture. The skill ceiling didn’t drop — it rose. There was more to master, not less, because the scope of what you could attempt had expanded enormously.
“The masters will refuse”
Alan Turing saw this pattern coming even earlier. In his 1947 lecture to the London Mathematical Society — a full decade before FORTRAN shipped — Turing divided those who would work with computing machines into two classes: the “masters”, who design and build the machines, and the “servants”, who operate them. He predicted that “as time goes on the calculator itself will take over the functions both of masters and servants.”
And then he added this:
“It may happen however that the masters will refuse to do this. They may be unwilling to let their jobs be stolen from them in this way.”
Turing was describing, in 1947, the exact emotional reaction that many of us have to AI coding assistants today. The reluctance isn’t about capability. It’s about identity. The masters don’t just perform a function — they are that function. And when a machine threatens to take it over, the response is not rational calculation but something closer to grief.
He was right. The masters always resist. And they’re not wrong to feel what they feel. But they are wrong about what happens next.
The loom and the automobile
It’s not only creative or intellectual crafts that follow this pattern.
When the power loom mechanised weaving in the early 19th century, skilled handloom weavers saw their livelihoods destroyed. The Luddite uprising wasn’t irrational — these were people watching their craft, their income, and their community dissolve. The immediate pain was real and devastating.
But weaving didn’t disappear. It scaled. The textile industry became one of the engines of industrialisation, and the skills required shifted from manual dexterity to machine operation, quality control, pattern design, and eventually industrial engineering. The craft moved up from the loom to the factory.
The automobile tells a similar story from a different angle. When motor cars began replacing horse-drawn transport in the early 20th century, the disruption was enormous. Blacksmiths, farriers, stable hands, carriage makers — entire trades built around the horse economy shrank or vanished. In 1900, New York City had roughly 100,000 horses working its streets. By 1920, the horse was already a rarity in most American cities.
But the need to move people and goods didn’t disappear — it exploded. The automobile created demand for mechanical engineers, road builders, traffic planners, and eventually an entire logistics industry operating at a scale that horse-drawn transport could never have supported. Henry Ford’s assembly line alone created more jobs than the carriage industry ever employed. The skill moved from handling animals to designing systems.
In every case, the people who suffered most were the ones whose skills were purely in the layer that got automated. And the people who thrived were the ones who could operate one level above.
You already took the deal
Here’s the part that most of us, as programmers, don’t think about enough.
We already made this trade. Most of us don’t write assembly anymore. We don’t hand-manage memory in the majority of our work. We don’t write our own sorting algorithms. We use compilers, garbage collectors, and standard libraries — every single one of which provoked the same “a machine can’t do this as well as a human” reaction when it was introduced.
And we don’t mourn it. Nobody sits at their keyboard writing C++ and thinks, “If only I were hand-coding x86 instructions right now — that was the real craft.” The craft moved, and we moved with it, and it happened so gradually that we forgot we ever made the trade.
AI is the next iteration of the same pattern. The layer being automated is different — it’s not machine code, it’s the generation of higher-level code itself — but the dynamic is identical. The machine handles what it can handle. The human moves up to what the machine can’t.
What’s different this time (and what isn’t)
I don’t want to be dismissive of the real anxieties. There is something different about this round.
When compilers replaced hand-coded assembly, the new layer was clearly defined. You wrote FORTRAN instead of machine code, and the skill of writing good FORTRAN was a recognisable, learnable craft. The transition had a destination.
With AI, the destination is fuzzier. “Write good prompts” doesn’t feel like a craft yet. “Review AI-generated code” doesn’t carry the same sense of mastery as writing code from scratch. The new layer exists but it hasn’t crystallised into something that feels like yours.
But I think that’s a symptom of the transition, not a permanent state. The painters of the 1840s didn’t wake up one morning and say, “Great, photography freed me — I’ll go invent Impressionism now.” It took decades. We’re in the awkward period. The old craft is being automated. The new craft hasn’t fully formed yet. And the space in between is uncomfortable.
But the pattern is clear. The craft moves up. It always has. And the people who do well are not the ones who cling to the layer being automated — they’re the ones who learn to operate in the layer that still requires human judgment, taste, and vision.
The question that remains
When I look at these historical parallels, I don’t only see a story of loss. I see a story of relocation. And in each case, there was a period of real pain, real resistance, and real grief. The Luddites weren’t fools. Delaroche wasn’t entirely wrong. Sammet’s programmers weren’t paranoid.
The question isn’t whether the craft will move this time. It’s whether we’ll move with it — and whether we can build something in the new layer that feels as good as what we’re leaving behind. I’m going to explore that part in my talk at Meeting C++ in November.
Connect deeper
If you liked this article, please
- hit on the like button,
- subscribe to my newsletter
- and let's connect on Twitter!
- if you're preparing for a C++ quant/trading interview, check out GetCracked