Andrej Karpathy: Software is undergoing a fundamental change again.

Author: Techub News Compilation

Introduction

Recently, former Tesla AI Director and founding member of OpenAI, Andrej Karpathy, shared his thoughts on the fundamental transformation of software under the AI wave during a speech aimed at students and industry newcomers. As a seasoned expert deeply involved in autonomous driving and cutting-edge AI research, Karpathy's perspective combines technical depth and historical insight. He believes that we are undergoing a dramatic shift in software paradigms not seen in 70 years, which is not only reshaping development tools and infrastructure but also redefining "programming" itself and the way humans collaborate with machines. This speech systematically sorted the evolution from Software 1.0 to 3.0 and looked ahead to the key challenges and opportunities in building the next generation of AI-native applications and ecosystems.

Summary

Software is undergoing a third fundamental paradigm shift: from code (1.0) to neural network weights (2.0), and then to programming large language models (3.0) with natural language prompts.
Large language models (LLMs) can be seen as a new type of "computer" or "operating system," whose ecosystem development is similar to early computing in the 1960s, primarily accessed through cloud-based time-sharing.
LLMs are a "human spirit" with human-like psychology but cognitive flaws; to collaborate effectively, we need to build "partially autonomous" applications with "autonomy sliders," customized GUIs, and rapid "generate-validate" cycles.
Natural language programming (such as "vibe coding") significantly lowers the barriers to software construction, while optimizing digital infrastructure (such as LLM-friendly documentation and protocols) for AI agents presents a huge new opportunity.
The path to fully autonomous AI agents will take longer than expected; priority should be given to building augmented tools under human supervision ("Iron Man suit") rather than fully autonomous agents.

The Three Paradigm Revolutions of Software: From Code to Weights to Prompts

Andrej Karpathy began by noting that now is an "extremely unique and interesting" time to enter the technology industry, primarily because "software is changing once again". He reviewed the historical paradigms of software development:

Software 1.0 refers to the traditional computer code we are familiar with, which is a precise set of instructions written by humans to command computers to perform tasks. GitHub is a typical representative of its code repository.

Software 2.0 is a concept proposed by Karpathy years ago, referring to the weights of neural networks. Programmers no longer write logic directly but instead "program indirectly" by preparing datasets and running optimizers to generate the parameters of the network. Platforms like Hugging Face can be seen as a "GitHub" for Software 2.0. For example, the large parameter set of the image generation model Stable Diffusion and the various variants generated by fine-tuning are regarded as "commit records" in this space.

However, until recently, most neural networks were still "fixed-function computers," such as image classifiers. The real transformation came with large language models (LLMs) making neural networks programmable. Karpathy believes this deserves to be called Software 3.0. In the 3.0 paradigm, the prompt is the program, written in natural language (such as English), used to "program" this new type of computer called LLM. He remarked on Twitter: "What's striking is that we are now programming computers in English." This completely changes the entry threshold and form of programming.

He used the example of an emotion classification task: in the 1.0 paradigm, one needed to write Python code to define rules; in the 2.0 paradigm, one needed to train a dedicated neural network; and in the 3.0 paradigm, one simply needed to design a prompt containing a few examples to give to the LLM. Nowadays, a large amount of code with English comments has emerged in code repositories on GitHub, indicating the rise of a new programming paradigm.

Karpathy illustrated the power of paradigm shifts with his experience developing autonomous driving (Autopilot) at Tesla. Initially, the Autopilot stack contained a significant amount of C++ code (Software 1.0) and some neural networks for visual recognition (Software 2.0). As the system evolved, the capabilities and scale of neural networks grew, replacing many complex functions originally implemented in C++ (such as multi-camera image information fusion over time and space), leading to the deletion of a substantial amount of 1.0 code. Software 2.0 "swallowed" the software stack. He anticipates a similar process will repeat in Software 3.0.

Thus, for developers, mastering these three paradigms is essential. Each paradigm has its advantages and disadvantages, and developers need to decide based on specific functional requirements whether to use traditional code, train a dedicated model, or directly prompt the LLM, while being flexible in switching between different paradigms.

LLMs: New "Operating Systems", New "Computers", and New "Public Utilities"

So how can we understand LLMs, this new phenomenon? Karpathy proposed several clever analogy frameworks.

First, LLMs are akin to "public utilities". As Andrew Ng stated, "AI is the new electricity," LLM labs (such as OpenAI, Google, Anthropic) invest heavily in training models, similar to building a power grid; providing intelligent services through APIs is equivalent to operating a power grid, with billing based on usage (per million tokens). Users have demands similar to public utilities: low latency, high availability, and stable quality. Even when top LLM services are interrupted, it can trigger "intelligence downgrades" globally—the world temporarily becomes "dumber."

Secondly, due to the high capital expenditure (Capex) required to train LLMs and the rapid iteration of technology, the core R&D capabilities are concentrated in a few labs, making it somewhat like a semiconductor manufacturing plant (Fab). Using NVIDIA GPUs for training is like a "fabless" model, while companies like Google, which develop their own TPUs for training, resemble Intel's model of having its own foundry.

However, Karpathy believes that the most apt analogy is to view LLMs as "operating systems". They are not just homogenized commodities like electricity or water, but increasingly complex software ecosystems. The current landscape bears a striking resemblance to the operating system market: there are a few closed-source providers (such as the GPT, Claude, and Gemini series, corresponding to Windows, macOS), along with an emerging open-source alternative (the Llama ecosystem, corresponding to Linux).

He compared LLMs themselves to the "CPU" of a new type of computer, with the context window serving as "memory," while the LLM coordinates memory and computational resources to solve problems and integrates functions like tool usage and multi-modality—this is entirely an operating system architecture. Many applications (such as the code editor Cursor) can run on different LLMs (GPT, Claude, etc.), just as VS Code can run on Windows, Linux, and macOS, simply by selecting from a dropdown menu.

We are in a stage akin to the early phase of "time-sharing computing" in the 1960s. LLM computation remains expensive, forcing concentration in the cloud, with users interacting in a "client" form over the network, unable to monopolize the whole machine, hence adopting time-sharing is economical. The true "personal computing revolution" has yet to arrive, but there are signs (such as local running of certain LLMs on Mac Mini). Currently, we mainly interact with this "operating system" through text terminals (like the ChatGPT chat interface), and a universal graphical user interface (GUI) has not yet emerged.

Karpathy particularly highlighted one "unprecedented" characteristic of LLMs: the direction of technological diffusion is "reversed." Typically, transformative technologies like electricity, cryptography, and early computers are first adopted by governments, militaries, or large corporations before diffusing to consumers. However, LLMs are doing the opposite: the first popular applications address everyday life issues like "how to boil an egg," with ordinary consumers leading the way, while enterprises and government institutions lag in adoption. This is because LLMs, being software, can be instantaneously deployed to billions of devices worldwide over the internet, a diffusion speed and pattern that is unprecedented.

Dancing with "Human Spirits": The Psychology and Collaborative Methodology of LLMs

To program LLMs effectively (Software 3.0), one must first understand what they are. Karpathy likes to regard LLMs as "Human Spirits"—a random simulator based on autoregressive Transformers, modeling human text. Since they are trained on vast amounts of text produced by humans, they exhibit human-like psychological traits but also have significant cognitive flaws.

Their "superpowers" include: encyclopedic knowledge and memory (comparable to the autistic savant in the movie "Rain Man"), far surpassing any individual human.

Their "cognitive flaws" include:

Hallucinations: they can fabricate facts and have a poor understanding of the limits of their own knowledge.
Jagged Intelligence: they may perform super-humanly in some areas but make basic mistakes on other simple questions (such as insisting that 9.11 is greater than 9.9 or stating that "strawberry" has two 'r's).
Anterograde Amnesia: unlike human colleagues who can consolidate memories and accumulate expertise through sleep, LLMs have fixed "weights," and their "context window" is just their working memory, cleared after each conversation, similar to the protagonists in the movies "Memento" or "50 First Dates." How to enable LLMs to learn continuously remains an unresolved issue.
Safety Issues: they are susceptible to prompt injection attacks and may leak data, showing excessive trust.

Thus, the core challenge in collaborating with LLMs is: how to bypass their cognitive flaws while fully utilizing their superpowers. This leads to what Karpathy believes is the largest opportunity area: building "partially autonomous" LLM applications.

For programming, directly using ChatGPT to copy and paste code is inefficient. Specialized applications like Cursor showcase the ideal form of LLM applications:

Automated Context Management: LLMs automatically handle file embeddings, code comprehension, etc.
Multi-Model Invocation Coordination: coordinating chat models, code completion models, code difference application models, and more.
Application-Specific GUI: This is key. Text interactions are hard to read and audit. GUIs (such as graphical displays of code differences) allow humans to quickly verify AI's work, significantly speeding up the collaboration loop through keyboard shortcuts (Cmd+Y to accept/Cmd+N to reject).
Autonomy Slider: users can control the degree of autonomy of the AI. In Cursor, from Tab completion (low autonomy) to modifying selected code blocks (medium autonomy) to allowing the AI to freely modify the entire repository (high autonomy), users can flexibly adjust based on task complexity.

An additional example is Perplexity AI, which possesses similar characteristics: packing information, orchestrating multiple LLM calls, providing auditable source citing GUIs, and offering varying levels of autonomy from quick searches to in-depth research.

Karpathy predicts that a vast amount of software will become "partially autonomous". The key question is: Can LLMs see everything humans can see? Can they perform operations that humans can perform? Can humans effectively supervise and remain in the loop? Because current LLMs are still imperfect and error-prone systems.

He emphasized the importance of accelerating the "generate-validate" loop. Human-AI collaboration typically involves AI generating, and humans validating. To make this loop faster: 1. Accelerate Validation: GUIs are crucial. Visual information processing is the fast track to the human brain, while reading text is much more laborious. Graphical representations (like icons and color-coded differences) can significantly enhance auditing efficiency. 2. Keep AI on a Leash: Avoid overly pursuing fully autonomous agents. Allowing AI to generate changes of 10,000 lines of code at once is meaningless, as human validation becomes the bottleneck. We need to control the scale of AI's output, keeping it small, incremental, and easy to validate.

He shared his best practices for AI-assisted coding: focus on small, specific tasks, maintain a rapid iteration loop, and avoid large changes. Vague prompts can lead to validation failures and loop stalling, so spending time to conceive more specific and precise prompts is worthwhile.

In the education sector, he envisions breaking down "teaching" into two applications: one for teachers to create standardized courses (auditable intermediate products) and another for students to learn that course. This confines the AI within a predefined teaching syllabus and project schedule, preventing it from "getting lost in the woods."

Karpathy warns against the long and challenging path to full autonomy, drawing from his experiences developing autonomous driving at Tesla. He had encountered a perfect self-driving demonstration back in 2013, but 12 years later, issues still remain unresolved, and humans are still in the loop. Therefore, he expresses concern over the notion that "2025 is the year of agents," believing it will be "the decade of agents," requiring ongoing human supervision. He prefers the analogy of "Iron Man's suit": the suit is both a tool for enhancing human capabilities (augmentation) and has a degree of autonomy (agentic). At this stage, when LLMs still have flaws, we should build more "suits" that enhance human capabilities (partially autonomous products) rather than fully autonomous "robots." These products should feature customized GUI/UX aimed at accelerating human-machine collaboration loops but simultaneously include the "autonomy slider," preparing for gradual increases in automation levels in the future.

Reconstructing Vibe Coding, Intelligent Agents, and Digital Infrastructure

Another revolutionary impact of Software 3.0 is that programming languages have turned into natural languages (like English). This means that almost everyone has become a potential programmer, without needing 5-10 years of professional learning.

The concept of "Vibe Coding" proposed by Karpathy has resonated significantly online. It describes a state where developers do not precisely specify requirements but instead collaborate with LLM through feelings and iterations, quickly building customized prototypes. He shared his experiences with "vibe coding": he built a basic iOS application in a day without knowing Swift; he also created MenuGen.app, an application that generates images for restaurant menus (although it is currently a "negative revenue" project).

However, building usable prototypes (that run locally) is relatively easy, while turning them into real products (involving operations work such as authentication, payment, deployment, etc.) is exceptionally cumbersome. These tasks often do not involve coding but rather clicking various configurations on a webpage. Karpathy expressed frustration: "The computer is telling me where to click. Why is ‘I’ doing this? Why isn’t ‘you’ (the computer) doing it?”

This leads to the final thematic part of the speech: Can we directly build infrastructure for AI agents?

Karpathy pointed out that a new category of digital information consumers and manipulators has emerged: previously, there were only humans (through GUIs) and computers (through APIs), but now there are also "human spirit" type AI agents. We need to adjust the digital world to accommodate them:

LLM-friendly Documentation: A large amount of existing documentation is designed for human reading (with lists, bold text, images) and is difficult for LLMs to parse. Documentation in formats like Markdown, which are easily understood by LLMs, should be provided. Companies like Vercel and Stripe have started to offer LLM-specific API documentation.
From "Click" to "cURL": "Click here" in documentation is ineffective for LLMs. Vercel is replacing "click" in documentation with equivalent cURL commands so that agents can execute directly.
Dedicated Protocols: Like Anthropic's proposed "Model Context Protocol," aimed at providing standardized interaction methods for agents.
Convenient Data Ingestion Tools: For example, replacing "github.com" in GitHub repository URLs with "git-ingest.com" can yield a single text suitable for direct pasting to LLM, comprising all code files. There are also tools that can automatically generate deep analysis documentation for codebases, facilitating LLM understanding.

While future LLMs may learn to click and navigate existing interfaces, Karpathy believes that actively engaging to "meet LLM halfway" and optimizing infrastructure to make information access easier remains a cost-effective approach, especially for a large amount of long-tail software that won’t adapt proactively.

Conclusion: Embracing a New Era of Software

Andrej Karpathy concluded that now is an amazing time to enter the tech industry. We need to rewrite the vast amount of code, which will be accomplished by professional developers and "vibe coders" working together.

LLMs are both public utilities and akin to fabs, but most importantly—they are "operating systems" in the early 1960s stage. What we are collaborating with are these "human spirits" that have both superpowers and cognitive flaws. To collaborate efficiently, we must adjust development practices (building partially autonomous applications, accelerating the generate-validate loop, and keeping constraints on AI), and reshape digital infrastructure to accommodate these agents.

Looking back at the analogy of the "Iron Man suit," we will witness the "autonomy slider" slowly but surely move from left to right over the next decade. This is a long process requiring patience, rigor, and creativity, but it is undoubtedly one of the most exciting chapters in software history. Karpathy finally expressed: "I can’t wait to build this future with all of you."

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。