[KongchangAI]
· 2 min read· 1,145 words

Has AI Solved Programming? Jonathan Blow's Doubts Are Worth Pondering

Has AI Solved Programming? Jonathan Blow's Doubts Are Worth Pondering

Blow questions the narrative that AI has solved programming: code generation does not equal improved software engineering quality.

The article centers on a counter-question from indie game developer Jonathan Blow: if AI has truly solved programming, why is the software in our hands still the same as ever? The author notes that this skepticism is not a denial of AI's progress, but a distinction between "AI can generate code" and "software engineering problems have been solved." AI excels at local tasks but struggles with system-level challenges such as architectural decay, debugging difficulties, performance bottlenecks, and maintenance costs; as the coding barrier drops, the burden of review, integration, and verification may actually increase. Drawing on limited discussion signals from Hacker News, the article calls for a more honest assessment of AI programming tools: focusing on where they truly reduce workload and where they merely shift complexity elsewhere.

When AI programming becomes the dominant narrative, are we missing something?

With AI-assisted programming tools proliferating, claims that "AI will replace programmers" or that "programming has been solved" appear frequently. Yet in a talk, renowned indie game developer Jonathan Blow raised a sharp counter-question: If AI has truly solved programming, why is my software still the same as ever? The discussion drew attention on Hacker News; though it did not generate much volume, it touched on a neglected corner of the current AI programming narrative.

Blow is known for developing Braid, The Witness, and other works, and has long focused on efficiency issues in programming languages and toolchains. His skepticism is not a denial of AI's progress, but a reminder: while we celebrate AI's ability to write code, have the complexity, reliability, and development experience of software itself fundamentally changed?

Jonathan Blow is the designer of the indie games Braid (2008) and The Witness (2016), both known for their ingenious mechanic design and high level of polish, which have made him one of the most closely watched indie developers in gaming. Beyond games, in recent years he has devoted substantial energy to developing a programming language called Jai, aimed at solving C++'s long-standing pain points in compile speed, metaprogramming capability, and development iteration efficiency. Because of this, he has a first-hand, practical stance on the question of "whether tools can truly improve the programming experience": he is both a user of efficiency tools and a designer of them. Understanding this background helps grasp his starting point when questioning the AI programming narrative—what concerns him is not whether AI can write code, but whether developers achieve substantive improvements in efficiency and quality in real projects.

hackernews source: Jonathan Blow – If AI Solved Coding, Why Is My Software Still the Same? [video]

hackernews source: Jonathan Blow – If AI Solved Coding, Why Is My Software Still the Same? [video]

hackernews source: Jonathan Blow – If AI Solved Coding, Why Is My Software Still the Same? [video]

Core argument: the gap between efficiency tools and engineering reality

According to the discussion on Hacker News, the core of Blow's talk lies in contrasting the vast chasm between "AI can generate code" and "software engineering problems have been solved." AI can quickly produce code snippets, but software projects still face the old problems of architectural decay, debugging difficulties, performance bottlenecks, and high maintenance costs.

This leads to a key distinction: code generation does not equal improved software quality. An AI that can write a sorting algorithm is not the same as one that can help you maintain a million-line legacy system. Blow's observation points to the limitations of current AI programming tools in real engineering scenarios—they excel at local tasks but struggle with system-level complexity.

Why hasn't software gotten better?

Complexity hasn't disappeared—it has shifted

AI lowers the barrier to writing code, but the core complexity of software—requirements understanding, architecture design, edge-case handling—has not disappeared as a result. On the contrary, when code becomes easier to generate, the burden of review, integration, and verification may actually increase. Developers need to spend more effort judging whether AI-generated code is correct, safe, and compliant with project standards.

"Complexity shift" has a more classic formulation in software engineering: the distinction between essential complexity and accidental complexity. The former stems from the problem itself—the ambiguity of requirements, the entanglement of business rules, concurrency and state management; the latter comes from deficiencies in tools, languages, and processes. AI programming tools mainly compress accidental complexity, such as boilerplate code, the burden of memorizing APIs, and syntax details; but they are nearly powerless against essential complexity. More subtly, when the cost of generating code drops, teams may tend to stack features faster, thereby increasing the system's overall essential complexity and adding to the burden of review and verification. This is precisely the engineering logic that can be formalized behind Blow's skepticism.

Advances in the toolchain do not equal a qualitative change in the development experience

Blow has long criticized efficiency problems in modern software toolchains. AI programming assistants can be seen as one link in the toolchain, but if the underlying language design, compiler performance, and debugging experience have not fundamentally improved, enhancements to a single-point tool can hardly bring about a leap in overall development efficiency. This stands in sharp contrast to the grand narrative of "AI solves programming."

The toolchain generally refers to the entire set of components that a program depends on from source code to a runnable program, including the compiler, linker, build system, debugger, package manager, and static analysis tools. Blow's criticism of modern toolchains centers on slow compilation, long feedback loops, and the difficulty of locating problems caused by stacked layers of abstraction. AI programming assistants sit upstream in this chain—they affect the "writing" stage, and if the experience of compilation, debugging, and performance profiling does not improve in tandem, developers' overall iteration speed will still be dragged down by downstream bottlenecks. In other words, speedups from a single-point tool are easily offset by the slowest link in the system, which is why evaluating the benefits of AI programming requires distinguishing between "local acceleration" and "end-to-end acceleration."

Discussion signals from Hacker News

The talk received 20 points and 5 comments on Hacker News. The discussion was not particularly heated, but the existence of the comment section shows that this skepticism resonated with some developers. Against the backdrop of heavy promotion of AI programming tools, this calm voice offers a valuable counter-perspective: Are we using "AI can write code" to paper over the unresolved challenges of software engineering itself?

A note: the above discussion is based on limited information from the Hacker News entry; the full content of the talk and the specific details of its arguments were not available. Therefore, the analysis in this article is more an extended reflection on its core questions rather than a paraphrase of the full talk.

A rational view of AI programming tools

Blow's skepticism is not meant to deny the value of AI programming, but to call for a more honest assessment. AI can indeed improve efficiency in scenarios such as code completion, boilerplate generation, and documentation lookup, but equating it with "the programming problem has been solved" is an oversimplification. For developers and technical decision-makers, the more meaningful questions are: In which specific areas do AI tools truly reduce workload? In which areas do they merely shift complexity elsewhere?

Improving software quality depends on multiple dimensions, including requirements clarity, sound architecture, test coverage, and team collaboration, and AI is only one variable among them. Treating it as a panacea may instead obscure the engineering problems that truly need investment.

Conclusion

The power of Jonathan Blow's counter-question lies in its use of the simplest reality to test a grand narrative: if programming has truly been solved, the software in our hands should be better, more reliable, and easier to maintain. The reality is that the old problems of software engineering still exist. This does not mean AI has no value; rather, it reminds us to maintain a clear understanding of engineering reality amid the technology hype.

#Jonathan Blow#AI programming#software engineering#code generation#AI programming tools
Share:

Related articles