Software 1.0, 2.0, 3.0
A three-paradigm framework for understanding the evolution of programming, articulated by Andrej Karpathy.
The three paradigms
Software 1.0 — explicit rules
Traditional programming: engineers write code specifying exact logic. Deterministic. The program exists in text files; its behaviour is constrained by what can be expressed in code.
Software 2.0 — neural networks
Programming shifts into curating datasets and training neural networks. The program is implicit in the weights; behaviour is shaped by the distribution of training examples, not explicit rules. Karpathy introduced this framing around 2017 in the context of Tesla Autopilot.
Software 3.0 — prompting
The programmer no longer writes code or curates training data. The LLM is the interpreter; the context window is the lever. The programming artefact is a prompt in natural language. Anyone who can write can now program — the language of programming is human language.
Each paradigm eats the one before
In his 2025 YC AI Startup School keynote (Andrej Karpathy on Software 3.0, LLMs as Operating Systems, and Partial Autonomy), Karpathy grounds the framework in Tesla Autopilot. The stack began with a great deal of hand-written C++ and a few neural networks for image recognition. As the networks grew, they took over work such as stitching information across cameras and across time, and the C++ that had done it was deleted: ‘the software 2.0 stack quite literally ate through the software stack of the autopilot.’ He expects Software 3.0 to eat through the stack in the same way, and advises new engineers to be fluent in all three paradigms, choosing per feature whether to write code, train a network or prompt a model.
Key implication: some apps shouldn’t exist
In a Software 3.0 paradigm, intermediary code that exists purely to coordinate steps that an LLM could perform natively becomes spurious. Karpathy’s MenuGen example: an OCR pipeline + image generation API + web app, versus a single multimodal prompt that annotates the menu directly. The first is Software 1.0 overhead; the second is Software 3.0.
Pushed further: genuinely new capabilities now exist that could not have been built in Software 1.0. There is no traditional program that takes a document collection and compiles it into a wiki. An LLM can do this natively.
The neural computer endpoint
Extrapolating Software 3.0 to its logical limit: a device that takes raw audio/video as input, runs it through a neural network, and renders a UI customised to that moment — no OS, no app layer. CPUs become co-processors; the neural network is the host process.
Karpathy draws an analogy to computing in the 1950s–60s, when both the calculator path and the neural-network path were live options. The calculator path won. Now the diagram may flip: intelligence compute is already the dominant share of FLOPs. The endpoint is ‘extremely foreign.‘
Relationship to vibe coding and agentic engineering
- Vibe Coding is Software 3.0 in practice: natural language narration → agent produces software.
- Agentic Engineering is the professional discipline of working in Software 3.0 while maintaining quality.