The Endgame of AI Programming: Why It Might Return to Assembly Language

A Bold Prediction: AI Programming Returns to Assembly

I recently came across a rather controversial viewpoint on Bilibili: the ultimate form of AI programming might be a return to assembly language. At first glance, this seems counterintuitive—programming languages have been evolving toward higher levels of abstraction for decades, so why would we "regress" back to assembly? But upon careful reflection, the logical chain is actually quite self-consistent.

The Core Logic: Removing "Humans" from the Equation

Why Do High-Level Languages Exist?

The high-level languages we use today—Python, Java, Go, and others—fundamentally exist to solve one problem: making code readable and maintainable by humans. From assembly to C, from C to Java, from Java to Python, each increase in abstraction level sacrifices some runtime efficiency in exchange for human readability and development productivity.

To understand this, we need to look back at nearly 70 years of programming language evolution. From machine code in the 1940s to today's Python, programming languages have undergone several abstraction leaps: Assembly language (1950s) replaced binary instructions with mnemonics—the first concession to human cognition; FORTRAN (1957) and COBOL (1959) introduced syntax resembling natural language, marking the beginning of the high-level language era; C (1972) found a balance between portability and performance; object-oriented languages (Smalltalk, C++, Java) further used classes and objects to simulate human conceptual thinking; modern languages like Python pushed development efficiency to the extreme, even at the cost of runtime performance. Behind each layer of abstraction, compilers or interpreters silently handle the "translation" work, and these translation layers are essentially engineering compensations for human cognitive limitations.

In other words, all high-level programming languages exist because "humans" need to participate in the programming process. Compilers, interpreters, virtual machines—these intermediate layers all consume computing resources, and their sole reason for existence is to bridge the gap between human thinking and machine instructions.

When AI Doesn't Need to "Understand" Code

If AI completely takes over programming, the situation changes entirely:

• AI doesn't need readability: Assembly language is obscure and difficult for humans, but for AI, it's no fundamentally different from Python—both are just sequences of symbols
• AI doesn't need abstraction: Humans need paradigms like object-oriented and functional programming to manage complexity, but AI can directly handle low-level details
• AI can optimize directly: Skipping the compiler's intermediate steps, it can directly generate optimal machine instruction sequences

This means that if "humans" are completely removed from the programming loop, high-level languages lose their reason for existence.

Current Bottlenecks in AI Programming Tools

Human Verification Remains the Biggest Constraint

What is the core problem facing current AI programming tools (like Cursor, GitHub Copilot, etc.)? Is it that AI can't write code? No. It's that humans still need to verify the code.

To understand this bottleneck, we need to look at the technical evolution of AI programming tools. The development of current AI programming tools can be divided into three phases: The first phase is code completion (GitHub Copilot, 2021), where large language models based on the Transformer architecture predict the next line of code through context—essentially statistical pattern matching; the second phase is conversational programming (ChatGPT Code Interpreter, Cursor, 2023), where AI can understand natural language requirements and generate complete functions or modules, though humans still need to review and integrate; the third phase is autonomous programming agents (Devin, SWE-agent, 2024), where AI begins to autonomously decompose tasks, call tools, run tests, and fix errors, forming a "think-act-observe" loop. The core driving force of this evolution is the improvement in models' reasoning capabilities (Chain-of-Thought) and tool-calling abilities (Function Calling/Tool Use), rather than mere parameter scale growth.

Precisely because humans need to understand AI-generated code, review logic, and debug errors, AI must output in high-level languages that humans can comprehend. This actually constrains AI's potential—it needs to accommodate human cognitive abilities rather than pursue optimal solutions.

If AI writes its own code, checks its own errors, tests itself, and deploys itself, it could work in the language closest to hardware, achieving the most extreme performance.

The Cross-Platform Problem: AI Can Handle It All

Different Instruction Sets? AI Writes Them All

Traditionally, one of assembly language's biggest disadvantages is non-portability—x86 assembly can't run on ARM, and ARM assembly can't run on RISC-V. This is one of the important reasons why high-level languages and compilers exist.

To understand the depth of this challenge, we need to understand the diversity of Instruction Set Architectures (ISA). An ISA defines the set of machine instructions a processor can understand—it's the fundamental contract between software and hardware. Current mainstream architectures include: x86/x86-64 (Intel/AMD, dominating desktop and server markets), ARM (dominating mobile, with Apple Silicon also based on it), RISC-V (an open-source emerging architecture rapidly growing in embedded and edge computing), MIPS (routers, game consoles, and other embedded devices), and PowerPC (some industrial control systems). These architectures differ significantly in register counts, memory addressing modes, and instruction encoding formats—the same assembly code is completely non-transferable across different architectures. The combination of high-level languages + compilers exists precisely to shield against this fragmentation—modern compiler infrastructures like LLVM use an Intermediate Representation (IR) layer to uniformly translate high-level language code into machine code for each architecture, which is why languages like Rust and Swift can easily support multiple platforms.

But for AI, this isn't a problem at all. For different instruction set architectures, AI can separately generate corresponding assembly code and can even perform specialized optimizations for each architecture. This is something human programmers cannot do—it's already difficult for one person to master a single assembly language, but AI can simultaneously master all architectures.

Sober Reflection: Is This Prediction Realistic?

Arguments Supporting AI Writing Assembly

1. Optimal performance: Removing all intermediate layers and directly controlling hardware can theoretically achieve the best performance
2. AI's capability boundaries are expanding: From code completion to autonomous programming, AI capabilities are indeed advancing rapidly
3. Logical consistency: If humans don't participate, there's truly no need to pay the cost for human readability

Real-World Challenges That Remain

1. AI reliability issues: Currently, AI is far from achieving 100% accuracy, and code that undergoes no human review poses enormous risks
2. Explainability requirements: In safety-critical system domains such as aviation, nuclear power, medical devices, and financial clearing, code explainability is not merely an engineering preference but a regulatory mandate. For example, DO-178C (aviation software standard) requires requirements traceability for every line of code; the FDA requires medical AI software to provide explainable paths for algorithmic decisions; financial regulators require algorithmic trading systems to be auditable for every decision's logic after the fact. Formal Verification technologies—such as Model Checking and Theorem Proving—can mathematically prove that code satisfies specific specifications, but these methods currently primarily target high-level languages or intermediate representations, and the complexity of formal verification for assembly-level code is extremely high. Therefore, even if AI could generate perfect assembly code, regulatory compliance requirements may still necessitate retaining a high-level language layer as an "auditable interface."
3. Debugging and maintenance: Even if AI writes assembly, when systems encounter problems, humans may still need to intervene for troubleshooting
4. A gradual process: From the current state to "AI fully autonomous programming" is still a long road ahead