The third revolution
Silicon's wake
...again, the revolution comes.
I watched a talk given by Andrej Karpathy at AI Startup School in June 2025. The talk is called “Software Is Changing (Again).”
Karpathy divides the history of software into three eras, which he calls Software 1.0, Software 2.0, and Software 3.0.
Software 1.0 is what most of us mean when we say software. A human being writes explicit instructions. The computer follows them. The instructions live in files. The files can be read, reasoned about, argued over, version-controlled. If something goes wrong, there is a line of code or data structure that caused it. You can trace failure through your logs. Success and failure operate in predictable, deterministic ways.
Software 2.0 arrived when using weights to program neural networks began replacing those explicit instructions. At Tesla, Karpathy watched neural networks eat the C++ codebase. Rule by rule. Function by function. The engineers who had written the rules did not immediately disappear. They just gradually became less central to the thing. The rules became training data. The training data became weights. The weights became something that could see, driving Tesla’s Autopilot.
Software 3.0 is where we are now. Using prompts we can instruct LLMs, marking a fundamental change as we move into programming in our native language. Karpathy claims that the same replacement will now happen between Software 3.0 and the other paradigms.
“The hottest new programming language is English.” — Andrej Karpathy
I want to be careful here, because “the programming language is English” sounds like a line from a pitch deck at a conference where the coffee is bad and the badges are laminated. It sounds like something someone says before showing you a slide with a very large number on it.
But Karpathy means it structurally. When you write a prompt, you are writing software. It is executed. It produces an output. The difference is that the compiler is a large language model, the syntax rules are loose enough to permit ambiguity and personality and occasional confident wrongness, and the results are probabilistic rather than deterministic.
This is not a metaphor. It is a description.
The uncomfortable implication is that everyone who uses an LLM is writing software. It is uncomfortable because many of the people writing this software would not think of themselves as writing software. They think they are having a conversation.
Meanwhile, the people who think of themselves as programming struggle to shift from a deterministic to a non-deterministic mental framework.
Consider the person writing a prompt right now. They type a sentence. The model completes the thought. The person reads what the model wrote and, finding it almost but not quite right, adjusts their prompt to steer toward what they actually meant. The model reads the adjustment and responds accordingly. With enough of these interactions, the act of creating crosses from the human to the machine and back again.
The black box
There is a black box at the centre of this.
Every revolution in software had one. In Software 1.0, the black box was the computer itself: you fed it instructions and trusted that the transistors did what they were supposed to do, without needing to understand semiconductor physics. In Software 2.0, the black box became the model: you fed it data and trusted the gradient descent, without needing to understand precisely how it learned what it learned.
In Software 3.0, the black box is the large language model. You feed it language. It produces language. Between input and output, something happens that no one, including the people who built it, can fully explain.
Karpathy describes the LLM as a new kind of computer. Not a new application. Not a new framework. A new substrate. He compares it to the early operating systems of the 1960s: expensive, centralised, accessed remotely by many users sharing the same machine, none of whom have full utilisation. We are all, right now, thin clients connected to a mainframe in the cloud.
The personal computing revolution has not happened yet in Software 3.0. We are just about past punch cards.
The persistence of memory
Engineering leaders talk of using LLMs as being like having an army of interns. But interns learn. That is, in some ways, the entire reason for interns to be in the business.
The LLM has a particular property that Karpathy names anterograde amnesia. It cannot form new long-term memories. Its knowledge is fixed at the point of training. After that, it can learn within a conversation, accumulate context within a session, follow a thread for as long as the thread is in front of it. But when the session ends, it ends entirely. The next conversation begins from nothing. The same questions asked again. The same ground covered again. No memory of having been here before.
What comes next are agents. Not the fully autonomous kind, the ones that have leaders talking excitedly of 10x productivity with a tenth of the people. A human remains in the loop. The AI generates. The human verifies. The loop runs. The speed is the thing: not that the human is removed, but that the cycle between attempt and correction accelerates until the combination is faster than either alone.
Karpathy calls the period we are entering the decade of agents. Not the year. The decade. A decade ago, we were told that driverless cars would be on every road by now. They are not. The technology moves at its own pace, indifferent to the urgency of the announcement.
This is, among other things, a warning about impatience.
I have been thinking about what it means to live inside a revolution that you are also trying to describe.
Every previous revolution was easier to see in retrospect. The industrial revolution was not called that by the people working in the mills. They were just working in the mills. The information age was not called that by the people writing COBOL in 1967. They were just writing COBOL.
We are in the unusual position of naming the revolution while it is happening.
There is one thing Karpathy says that I keep returning to. He says that a good software engineer right now should be fluent in all three paradigms. Not just the new one. Not just prompting. They should be able to write the explicit code, train the model, and write the prompt, and know which of the three is appropriate for the problem in front of them. The skill is not mastery of Software 3.0. The skill is knowing which era you are operating in.
This article was written in Software 3.0. Not entirely. Not even mostly. But the black box was present, generating and being corrected, in the way that Karpathy describes: the loop running, the human verifying, the attempt and the correction cycling faster than either alone could manage.
I did not set out to write about my own process. But the thing about living inside a revolution is that it keeps insisting on being noticed.
“Don’t put your trust in revolutions. They always come around again. That’s why they’re called revolutions.” - Terry Pratchett, Night Watch
Software is changing....