AI Replacing Programmers? This Prediction Has Been Made for 60 Years and Never Come True

A Prophecy Spanning Half a Century

"AI will replace programmers" — this rallying cry resurfaces with every wave of technological innovation. Today, as ChatGPT and various AI coding assistants sweep through the developer community, many believe the programming profession is heading toward extinction. However, a little-known fact is that this prediction didn't originate today — it can be traced back over 60 years to the 1960s.

According to a discussion circulating on Reddit (referencing an article from seanhelvey.com), a dual Turing Award and Nobel Prize laureate predicted as early as the 1960s that programming as a profession would eventually die out because computers would achieve "self-programming." This dual laureate was most likely Herbert A. Simon — who received the Turing Award in 1975 and the Nobel Prize in Economics in 1978, and was one of the founding figures of artificial intelligence. Simon, together with Allen Newell, developed early AI programs such as the "Logic Theorist" and the "General Problem Solver," and made several bold predictions in the 1960s, including the prophecy that within 20 years computers would be able to do any work that humans could do. His optimism was rooted in confidence in symbolic reasoning and heuristic search, believing that once machines mastered general reasoning capabilities, intellectual labor like programming would naturally be automated. Yet the time span of this prediction is staggering — from the mainframe era to cloud computing, from assembly language to large language models, programmers have not only survived but have become one of the most in-demand professions globally.

History Repeats Itself: Every Technological Breakthrough Is Called "The End"

Every Rise in Abstraction Level Triggers Panic

Looking back at the history of computer programming, the narrative of "programmers are about to lose their jobs" runs throughout, and each instance is closely tied to the emergence of a new level of abstraction.

In the late 1950s, when the high-level programming language FORTRAN was introduced, some believed it would make the "programmer" role redundant — because scientists and engineers could communicate directly with computers using language close to mathematical expressions, without needing specialized coders. FORTRAN (FORmula TRANslation) was released by John Backus's team at IBM in 1957 and was the world's first widely-used high-level programming language. Before it, programmers had to operate computers directly using assembly language or even machine code, with each instruction corresponding to a specific CPU operation. FORTRAN allowed programmers to express computational logic in a way close to mathematical formulas, with the compiler responsible for translating it into machine code.

One of COBOL's design goals was even to let business people write programs "in English," thereby bypassing programmers entirely. COBOL (COmmon Business-Oriented Language) was born in 1959, driven by Grace Hopper and others. Its syntax resembles English sentence structure, and its design philosophy explicitly included the goal of "enabling non-technical people to read and write programs." The emergence of these two languages represented the first major leap from "speaking to machines in machine language" to "speaking to machines in human language," and marked the first historical moment when the "programmers will become obsolete" narrative appeared at scale.

Yet reality shows that every rise in abstraction level not only failed to eliminate programmers but actually spawned more software, more complex systems, and demand for even more programmers. When programming becomes easier, people start using software to solve problems they previously couldn't have imagined tackling.

Why "Computer Self-Programming" Never Materialized

The "computer self-programming" envisioned by that Nobel laureate in the 1960s was essentially an optimistic extrapolation of compilers, code generators, and similar tools. Indeed, today's compilers can translate high-level languages into machine code, IDEs can auto-complete code, and frameworks can generate vast amounts of boilerplate code — these are all, in a sense, "computers programming."

But the key point is: what has always been truly scarce is never the act of "typing code" itself, but rather the cognitive ability to understand problems, decompose requirements, design architectures, and weigh trade-offs. Tools replace repetitive labor, not creative judgment.

The Relationship Between AI Coding Tools and Programmers: Mastery, Not Replacement

Tools Change How We Work, Not Whether We Work

History has repeatedly proven that new tools change how programmers work, not replace programmers themselves. When version control systems appeared, programmers learned to collaborate; when cloud platforms appeared, programmers were freed from operational chores; when AI coding assistants appeared, programmers began treating them as "pair programming partners."

Each time, programmers are liberated from lower-level repetitive labor to tackle higher-level, more valuable problems. This isn't replacement — it's amplification of capability.

New Variables and New Challenges Brought by Large Language Models

Today's large language models do bring variables that differ from the past. They can understand natural language requirements, generate runnable code, and even perform debugging and refactoring to a certain degree. This level of generality and flexibility is something no previous tool possessed.

From a technical standpoint, current mainstream AI coding assistants (such as GitHub Copilot, ChatGPT, Claude, etc.) are based on Large Language Model (LLM) technology. An LLM is essentially a probabilistic model that learns to predict the most likely next token given a context, trained on massive amounts of text data. This means its "understanding" is statistical rather than logical — it doesn't actually "execute" code to verify correctness, nor does it rely on formal reasoning to guarantee semantic accuracy of programs.

This explains why AI-generated code still requires humans to review, understand, integrate, and maintain. Models can "confidently produce nonsense" (the so-called "hallucination" phenomenon), generate hard-to-detect logical errors, and introduce difficult-to-trace technical debt in complex systems. In programming scenarios, such errors are particularly dangerous — a piece of code that appears reasonable but contains boundary condition errors might pass 99% of tests yet cause serious failures in production. Judging whether AI output is correct and meets business requirements itself requires solid engineering capability — which is precisely where programmers' core value lies.

Why Does the Prediction of AI Replacing Programmers Always Fall Short?

Jevons Paradox: Efficiency Gains Actually Expand Demand

In economics, there's a famous concept called "Jevons Paradox": when technological progress improves the efficiency of resource use, it actually leads to an increase in total resource consumption due to expanded demand, rather than a decrease. This concept was proposed by British economist William Stanley Jevons in 1865 in his book The Coal Question. He observed that James Watt's improvements to the steam engine dramatically increased coal usage efficiency, yet Britain's total coal consumption actually surged — because the efficiency gains lowered unit costs, vastly expanding the economically viable applications of coal.

This paradox has been repeatedly validated in information technology: declining storage costs gave birth to the big data industry, declining bandwidth costs gave birth to streaming and cloud computing, and declining computing costs gave birth to deep learning. It applies perfectly to software development — when programming becomes more efficient and cheaper, software application scenarios explode. Today, from smartwatches to autonomous driving, from AI customer service to quantitative trading, software is everywhere. Every improvement in development efficiency lowers the threshold for launching software projects, making more scenarios that were previously "not worth digitizing" become feasible. AI making coding faster will most likely not result in "needing fewer programmers," but rather "needing programmers to build more and more complex systems."

Engineering Complexity Always Migrates Upward

The greatest lesson from 60 years of history is this: the content of programmers' work has constantly changed, but the essence — "someone needs to define and solve problems" — has never changed.

From punch cards to natural language prompts, tool interfaces have become increasingly user-friendly, but the complexity behind the interface has been transferred rather than eliminated. This observation can be explained by the "Law of Requisite Variety" from systems theory — proposed by cybernetics co-founder W. Ross Ashby in 1956: for a control system to effectively cope with environmental complexity, it must possess at least an equal degree of complexity itself. In software engineering, this means that the complexity of real-world problems doesn't disappear because tools become more powerful — it simply shifts from one level to another. When frameworks handle the complexity of low-level network communication, developers face the complexity of distributed system consistency; when AI handles the complexity of code generation, developers face the complexity of verification, integration, and system-level design.

The real engineering challenges — system design, performance optimization, security assurance, requirements understanding — still require people with deep experience and critical thinking to address. Every evolution of the programming toolchain is a process of pushing complexity from the "implementation layer" toward the "decision layer."

Conclusion: Instead of Fearing Replacement, Proactively Master AI

The fact that a prediction from 60 years ago remains unfulfilled is itself the best footnote. This doesn't mean AI won't profoundly change the programming industry — it certainly will, just as high-level languages, compilers, and cloud computing all profoundly changed the industry before.

The real question has never been "will AI replace programmers," but rather "will programmers who use AI replace programmers who don't." For developers, rather than being anxious about replacement, it's better to proactively embrace tools and elevate your capabilities in problem definition and system design.

After all, history has told us time and again: the more powerful the tools become, the more valuable those who can master them will be.