Antirez on Controlling Ideas Over Code in the AI Era

The Shift from Code Review to Idea Control

Software engineering is undergoing a fundamental transition where the primary value of a developer is shifting from the ability to write and review code to the ability to control the "ideas" behind the software. According to Salvatore Sanfilippo (antirez), focusing on the manual review of code is becoming suboptimal and often pointless because LLMs can now generate vast amounts of locally optimal code faster than any human can realistically audit.

This shift does not imply "vibe coding" or blindly requesting a final product. Instead, it requires a rigorous focus on design, architectural prompts, and comprehensive quality assurance (QA). The goal is to ensure the mental model of the software is correct, rather than spending limited cognitive cycles on line-by-line syntax checks.

Why Manual Code Review is Becoming Obsolete

Three primary factors make traditional line-by-line code review inefficient in the age of frontier LLMs:

1. Volume of Output: The sheer volume of code generated by AI makes reviewing thousands of lines of code per day an impossible task for a human reviewer.
2. Local vs. Global Optimization: LLMs excel at writing locally optimal code (functions and blocks) but are less capable of managing "big ideas." Therefore, the developer's role is to prompt the design and evaluate if the overall model is correct, rather than scanning individual functions.
3. Opportunity Cost: The working day is finite. Time spent reading code is time taken away from higher-impact activities, such as defining new directions for the software, brainstorming optimizations, and conducting rigorous QA.

Implementing a Design-First Workflow

To maintain control over software without obsessing over the implementation details, antirez suggests moving toward a documentation-centric approach. Instead of relying on the code as the primary source of truth for design, developers should use LLMs to maintain a DESIGN.md file. This file should describe:

• Every data structure in human language.
• The core ideas and implementation tricks used.
• The overall architectural design.

By owning the ideas in a human-readable format, developers can provide AI agents with the correct mental model, making it far more efficient to modify the system than reading through thousands of lines of source code.

The Challenge for Junior Developers

There is a significant concern regarding how new programmers will develop the necessary "forma mentis" (mindset) to reason about architecture if they stop writing code. Antirez suggests that junior developers should not waste time reviewing mundane AI-generated code (e.g., "Javascript stuff for a customer website"). Instead, they should build their mental models by implementing fundamental computer science components from scratch, such as:

• Small interpreters
• Hash tables
• Small databases

Community Perspectives and Counterpoints

The proposal to stop reading code has sparked significant debate among experienced engineers, highlighting a tension between efficiency and trust.

The Trust and Verification Gap

Many developers argue that absolute trust in LLMs is dangerous. Since models still hallucinate and can produce subtle, non-obvious bugs, manual review remains a critical safety net.

"The models are indeed amazing... They do still hallucinate. WAY less than they used to but it's still non-zero. In a way that's worse b/c the model will spit out a complex piece of software and say 'Yep, no mistakes. I even wrote tests and they all pass!'"

Some suggest a hybrid approach: using LLMs to write code and tests, but manually verifying the unit tests themselves to ensure the verification logic is sound.

The Identity Crisis of the Programmer

For many, the act of reading and writing code is not just a means to an end, but the primary way they understand a problem. The suggestion to remove oneself from the code is seen by some as a threat to the professional identity of the engineer.

"The proposed idea of not reading the code you ostensibly wrote... challenges the identity of a programmer itself... reading other peoples code (and code the LLM writes) evolves the idea itself, and changes my understanding of it."

The "Training Data Loop" Concern

Some critics point out a potential systemic risk: if the world stops writing high-quality, human-curated code and instead fills repositories with LLM-generated "slop," future models will be trained on lower-entropy, mid-quality data, leading to a degradation in overall code quality over time.