I have everything I need. Writing lesson 9.
The bigger picture
The whole lesson in one sentence: the agent you have been building is not a clever script, it is a program written in English running on a new kind of computer, and once you see it that way the work changes.
Step back from the loop
Every lesson so far stayed close to the metal. A model calling tools in a loop. A system prompt. A context window you can fit in your head. That was deliberate. But there is a frame around all of it worth naming, because it explains why these small primitives keep working and where they are heading.
The frame comes from Andrej Karpathy, and it has three parts: prompts are a new kind of program, the model is a new kind of computer, and the knowledge you build with it can maintain itself. Hold all three at once and the agent stops looking like a trick and starts looking like the start of something.
Software 3.0: English is the program
Karpathy's split is three paradigms.
| Paradigm | What | Example |
|---|---|---|
| Software 1.0 | Humans write instructions in formal languages | Python, SQL, C |
| Software 2.0 | Weights learned from data, not written | Trained models, embeddings |
| Software 3.0 | Prompts as programs, written in natural language | System prompts, tool descriptions, CLAUDE.md, SKILL.md |
His line, from Software Is Changing Again (YC AI Startup School, June 2025): "Your prompts are now programs that program the LLM. And remarkably, these prompts are written in English." And the blunter version: "The hottest new programming language is English."
This is not a slogan. The system prompt you wrote in lesson 3 is a program. It has variables through interpolation, conditionals through few-shot examples, functions through tool calls, error handling through fallbacks. The difference from 1.0 is that there is no compile step. The runtime is an LLM call. You change a line, it takes effect on the next turn. The cost is that it is stochastic: the same prompt does not always return the same output. That is inherent, not a bug to be fixed.
Karpathy adds a second cut worth keeping. There are two modes of Software 3.0. The first is doing old work faster: refactoring code, building an app, transforming data. The second is producing outputs that had no 1.0 equivalent at all. His example is his own LLM wiki: "This is not even a program. This is not something that could exist before because there was no code that would create a knowledge base based on a bunch of facts." The second mode is the interesting one. If you only ask "how do I do my existing job faster," you miss it.
LLM-OS: the model is the computer
The second part of the frame is where Software 3.0 runs. Karpathy's claim is that the LLM is not an app sitting on top of an operating system. The LLM is the operating system.
| Classic OS | LLM-OS |
|---|---|
| CPU | LLM |
| RAM | Context window |
| Peripherals (browser, disk, GPU) | Tools (browser, Python, MCP servers) |
| Persistent storage | Internet + filesystem |
| Windows, macOS (closed) | GPT, Claude, Gemini |
| Linux (open) | Llama |
This is the same shape you have been building against the whole course, named differently. Context window as RAM is why context engineering matters: RAM is finite and expensive, and so is the model's attention budget. Tools as peripherals is why the agent-computer interface matters: peripherals need drivers and protocols, and tool descriptions plus JSON schemas play that role. Filesystem as disk is why writing notes to a folder works: you give the model a disk to read from and write to instead of stuffing everything into RAM.
Karpathy also dates us. "We're in the 1960s of this new computing era." Compute is expensive, so everything runs centralized in the cloud, and you are a thin client with a terminal to OpenAI, Anthropic, or Google. A personal LLM-OS does not really exist yet. The implication is that today's agent architecture is temporary. The way computing went mainframe to personal to mobile, LLM compute will decentralize when the hardware economics allow it. What you build now sits on the early, centralized end of that curve.
The self-evolving wiki: knowledge that maintains itself
The third part is an application built on top of LLM-OS, and it closes a loop that has been open for eighty years.
Vannevar Bush described the memex in 1945: a personal, curated archive with associative trails between documents. The part he never solved was who maintains it. He assumed the human would. Humans do not, because bookkeeping is boring and the maintenance cost grows faster than the value. Wikis die for this reason.
Karpathy's LLM wiki pattern hands the bookkeeping to the model. Three layers: raw sources you drop in and never edit, an LLM-generated wiki of summaries and concepts and cross-links, and a schema file (CLAUDE.md or AGENTS.md) that holds the conventions. Three operations: ingest a source and let it touch the ten-to-fifteen pages it affects, query the wiki and file good answers back as new pages, and lint periodically for contradictions, orphans, and stale claims.
Why it works: a pile of documents is additive, A next to B, no gain from the overlap. A compounding wiki is multiplicative, where each new source enriches the existing synthesis. The model does not get tired, does not forget a cross-reference, and can touch fifteen files in one pass. Maintenance cost drops toward zero, so the wiki stays current and actually compounds. Karpathy's own framing: "It's really just a lot of prompts for me to do synthetic data generation over some fixed data."
One warning he is firm about, and it applies to everything in this course. "You can't outsource your understanding. These are tools to enhance understanding." A wiki you never read is not an understanding tool, it is a memory bank. The compounding that matters is what compounds in your head.
Where it all connects
These are not three ideas. They are one. Software 3.0 is the language. LLM-OS is the machine that language runs on. The self-evolving wiki is what you build when you take both seriously: a program written in English, running on the model as a computer, that maintains its own state on disk. Every agent in this course was a smaller instance of the same shape.
Takeaways
- Your prompts are programs. The system prompt is Software 3.0, no compile step, stochastic by design.
- The model is the computer: context is RAM, tools are peripherals, the filesystem is disk. The whole course was engineering against that machine.
- A wiki the model maintains compounds because the bookkeeping cost goes to zero. But you still have to read it. Understanding does not outsource.
- We are in the 1960s of this. What you build now is the centralized, early version. The shape will move.
Where this goes next
There is no next lesson. That is the point. You started with a model calling tools in a loop, and you now have the frame around it: English as code, the model as a computer, knowledge that maintains itself. The frame does not build anything on its own. Go back to the loop. Pick a real task, write the smallest agent that could do it, watch where it breaks, and fix that. The understanding only compounds if you keep your hands on the work.