Software Is Changing (Again) - Andrej Karpathy

Software is changing again—this time less by rewriting programs and more by rewriting what “software” means. Andrej Karpathy frames three eras: Software 1.0 is explicit code that runs on computers; Software 2.0 is neural-network weights that replace large portions of hand-written logic; and Software 3.0 is prompts, where natural-language instructions function like programs that steer large language models. The practical implication is that modern development increasingly looks like tuning and orchestrating models and interfaces, not just authoring deterministic logic.

Karpathy argues that the shift is visible in how codebases evolve. In Tesla’s autopilot work, C++ logic gradually gave way to neural networks that absorbed capabilities—especially “stitching” information across camera views and time—until the neural stack “ate through” the software stack. The same pattern is now repeating in other domains: as models grow more capable, they replace brittle, fixed-function components with learned behavior. He also emphasizes that these paradigms have different strengths and failure modes, so fluency across them matters rather than treating one approach as universally superior.

A central theme is that LLMs behave like a new kind of computing layer—sometimes compared to utilities, fabs, or operating systems—but with a key twist: they’re distributed and accessed via time-sharing. Training requires massive upfront capital (capex), while serving is metered through APIs (opex), creating “utility-like” expectations such as low latency and high uptime. When major models go down, users experience an “intelligence brownout,” a reminder that people increasingly outsource not just facts but reasoning workflows.

Karpathy then zooms in on what makes LLMs distinct as software components. Prompts are written in English, a “programming language” that is flexible but ambiguous compared with traditional languages. He describes LLMs as stochastic simulators—autoregressive transformers trained on internet-scale text—capable of encyclopedic recall yet prone to hallucinations, jagged intelligence, and context-window limits. Unlike humans, they don’t naturally consolidate knowledge over time; working memory is constrained by context length, and long-term learning requires explicit mechanisms.

From there, the talk shifts to how LLMs are already reshaping software engineering through “partial autonomy” apps. Instead of chatting in a generic interface, tools like Cursor and Perplexity package model calls, context management, and verification into workflows with GUIs and an “autonomy slider.” The goal is fast generation plus human supervision: small diffs, rapid review loops, and mechanisms to keep models “on the leash” when prompts are vague or verification fails. Karpathy stresses that security and correctness can’t be reduced to quick code review; subtle system-level risks and cascading failures make automation dangerous without strong guardrails.

Finally, he argues that LLM adoption is also changing the digital information ecosystem. Documentation and interfaces are being adapted for machine consumption—moving toward LLM-readable formats, agent-friendly endpoints, and protocols that reduce friction (e.g., replacing “click here” instructions with actionable commands). The broader forecast is that the industry is entering a 1960s-like phase for a new computing paradigm: early, messy, and still constrained by cost and efficiency, but already powerful enough to trigger a new software stack and a new way of building.