Software 2.0

In the [YOU] on AI Field Guide

The Software 2.0 paradigm is the engine underneath the orange pill moment that [YOU] on AI describes. When a hundred dollars a month buys what once required a team of engineers, it is because the act of programming has changed so completely that someone who can describe what they want can now attempt to build it. Claude Code is Software 3.0 in operation; the democratization Edo Segal celebrates is downstream of Karpathy’s paradigm shift.

The concept also grounds the cycle’s most important caution. If the source code is the dataset, the machine can be no wiser, no fairer, and no more comprehensive than the examples it was given. The biases a system exhibits, the gaps in what it knows, the failure modes that surprise its builders—these are properties of the data rather than of the model. To control the system is first to control its diet, and controlling the diet is hard, unglamorous, human-judgment-laden work that the glamour of the architecture tends to obscure.

Andrej Karpathy

Origin

Karpathy published the essay that named the concept in 2017, while leading Tesla’s Autopilot vision team. He had noticed that the handwritten code was steadily being eaten by learned components—that the explicit C++ was shrinking and the neural network was growing, swallowing functionality that engineers had always specified by hand. The essay was partly descriptive, partly predictive, and partly a rebuke to a field that kept treating neural networks as just one tool in the machine learning toolbox rather than as the beginning of a new instrumentality.

The essay turned on a distinction between two kinds of source code. In the classical stack, the source is human-written instructions. In the new stack, it is a dataset that specifies the desired behavior through examples plus a neural network architecture that sketches the rough shape of the solution. The weights—the actual program—are found by optimization. Karpathy pointed out practical advantages the skeptic would miss: Software 2.0 is computationally homogeneous, runs efficiently on specialized hardware, and can be improved simply by adding more data and compute, with no human required to have a new idea. The trade is depth of understanding for breadth of capability.

Key Ideas

The dataset is the source code. Whoever shapes the data shapes the program. The neural network does not learn the world; it learns the dataset. And the dataset is always a particular, contingent, biased, incomplete sample of the world, assembled by particular people under particular constraints, carrying every limitation and distortion of its origins. This reframes the public anxiety about AI bias: the bias was not introduced by the algorithm but discovered by it, faithfully extracted from data that human activity produced.

Debugging becomes data collection. When a Software 1.0 program fails, you read the code, find the faulty line, and fix it. When a Software 2.0 system fails, there is no faulty line. There is a region of input space where the learned function behaves badly, and the remedy is to find or create data that covers that region and retrain. Understanding becomes statistics. The program is a black box not by design but because opacity is the price of letting the machine discover its own logic.

The data engine. At Tesla, Karpathy turned the Software 2.0 philosophy into an operating loop: the deployed fleet identified situations the model handled poorly, those situations were collected and labeled, the new data was folded into training, and the model improved precisely where it had been weak. The intelligence of the system was, in a real sense, the intelligence of this curation loop. The engineering genius lay not in the network but in the process that fed it—closer to teaching than to traditional engineering.

Software 3.0: English as programming language. When large language models made natural language the interface to computation, Karpathy extended his account. The model is the computer; English is the programming language; the prompt is the program. This is not a metaphor he uses loosely: the practice of getting an LLM to do what you want has the structure of programming—you compose instructions, observe the output, debug by revising phrasing, and build libraries of prompts that work. The difference is that the language is one billions of people already speak, which means the population of potential programmers has expanded by orders of magnitude in a single step.