Lecture, Conference Presentation
Andrej Karpathy: Software Is Changing (Again)
- Software Paradigm Evolution: Software is undergoing a fundamental shift, moving through three distinct eras:
- Software 1.0: Traditional code where humans explicitly write instructions (e.g., Python, C++) to direct computers.
- Software 2.0: Neural networks where humans tune datasets and optimizers to create weights that program the network, rather than writing logic directly (e.g., image classifiers).
- Software 3.0: Large Language Models (LLMs) where prompts written in natural language (English) act as programs that direct the model.
- Ecosystem Mapping: The software landscape now has direct equivalents across paradigms:
- Hugging Face serves as the "GitHub" for Software 2.0, hosting model weights and versions (e.g., Flux, LoRA).
- Model Atlas allows visualization of this software layer, treating model fine-tuning as a "Git commit."
- Historical Trajectory at Tesla:
- During the development of Tesla Autopilot, Software 2.0 (neural networks) systematically replaced Software 1.0 (C++).
- As neural network capabilities grew, traditional C++ code for tasks like stitching camera data was deleted and migrated to neural weights.
- LLM Utility Analogy:
- Infrastructure: LLM labs function as "fabs" requiring massive capital expenditure (Capex) for training and operational expenditure (Opex) for serving via APIs.
- Interoperability: Unlike hardware, software LLMs can be easily swapped (e.g., via OpenRouter) without competing for physical space, acting like multiple electricity providers.
- Risk: Widespread reliance on LLMs creates an "intelligence brownout" risk; if top-tier models go down, global productivity and capabilities drop significantly.
- LLM as Operating System:
- Architecture: LLMs function as a new OS where the model is the CPU, context windows act as memory, and tool use orchestrates problem-solving.
- Current Era: The industry is in a "1960s timesharing" phase where compute is centralized in the cloud, making personal local inference uneconomical despite emerging hardware (e.g., Mac Minis) capable of batch inference.
- Diffusion: Unlike historical technologies (electricity, computing) that diffused from government/corporation to consumer, LLMs diffused instantly to billions of individuals via the consumer internet.
- LLM Psychology and Limitations:
- Nature: LLMs are "stochastic simulations of people" trained on internet text, exhibiting encyclopedic memory but also specific cognitive deficits.
- Deficits:
- Hallucination: Frequent generation of incorrect facts or logical errors (e.g., 9.11 > 9.9).
- Enterograde Amnesia: Lack of native long-term memory consolidation; context windows act as working memory that resets, requiring explicit context management.
- Security: Vulnerability to prompt injection and data leakage.
- Development Strategy: Partial Autonomy:
- Tooling: Successful LLM apps (e.g., Cursor, Perplexity) utilize a "partial autonomy" model rather than full automation.
- Autonomy Slider: Users control the level of agency, ranging from code completion to full repository refactoring, allowing tuning based on task complexity.
- Human-in-the-Loop: Systems must keep the "AI on the leash" via granular verification loops to prevent over-reaction and security risks.
- GUI Importance: Graphical interfaces are critical for auditing AI output, as visual diffs are faster to review than textual logs.
- "Vibe Coding" Phenomenon:
- Definition: A term for rapid, informal app building using natural language prompts, bypassing traditional syntax learning.
- Success Case: The speaker built a functional iOS app and "MenuGen" (a menu photo-to-image generator) in hours.
- Bottleneck: While generating code is fast, the "slog" of DevOps, authentication, payments, and deployment remains a manual barrier for non-experts.
- Building for Agents:
- New Consumer Class: Agents act as a new class of digital information consumers that require machine-readable infrastructure.
- Documentation Shift: Developers must transition from human-readable docs (HTML, complex formatting) to LLM-readable formats (Markdown,
llms.txt). - Actionable Instructions: Documentation must replace human verbs like "click" with programmatic actions (e.g.,
curlcommands) to enable agent interaction. - Ingestion Tools: Emerging tools (e.g., Git Ingest, DeepWiki) convert raw repositories into structured, LLM-friendly text for easier agent access.
- Future Outlook:
- Decade of Agents: Full autonomy is a long-term goal; the immediate future involves incremental shifts from augmentation (Iron Man suit) to agents (Iron Man robot).
- Industry Impact: A massive rewrite of existing codebases is required to accommodate these new paradigms.
- Call to Action: Entering the industry now offers a unique opportunity to redefine software, requiring fluency in all three paradigms (1.0, 2.0, and 3.0).