Andrej Karpathy: Software Is Changing (Again) Software in the Era of AI: A New Programming Paradigm This blog post summarizes key insights from Andrej Karpathy's talk on software's evolution in the age of AI. He introduces the concept of Software 1.0, 2.0, and 3.0, highlighting the significant shift driven by Large Language Models (LLMs). Software 1.0, 2.0, and 3.0 Software 1.0 : Traditional computer code written by programmers. This is the code that directly instructs the computer. Software 2.0 : Neural networks, specifically their weights. Programmers don't write the code directly; instead, they tune datasets, and an optimizer generates the neural network's parameters. Hugging Face serves as a GitHub equivalent for Software 2.0, hosting a vast collection of pre-trained models. Software 3.0 : Large Language Models (LLMs) programmed via prompts written in natural language (e.g., English). This represents a fundamental shift, making programming accessible to a much wider audience. Example: Sentiment classification can be achieved through Software 1.0 (Python code), Software 2.0 (trained neural network), or Software 3.0 (LLM prompt). The emergence of Software 3.0 is a paradigm shift, with English becoming a programming language, blurring the lines between traditional coding and natural language interaction. LLMs: Utilities, Fabs, or Operating Systems? Karpathy draws insightful analogies to understand LLMs: Utilities: LLM labs (OpenAI, Google, Anthropic, etc.) invest heavily in training (capex), similar to building an electricity grid. They then offer metered access (opex) via APIs, mirroring utility services. The demand for low latency, high uptime, and consistent quality further strengthens this analogy. The potential for switching between different LLMs is also highlighted, similar to switching electricity providers. Fabs: The substantial capital expenditure required for training LLMs resembles the investment in semiconductor fabs. However, the software nature of LLMs makes them less defensible than physical fabs. Operating Systems: This analogy resonates most strongly. LLMs are complex software ecosystems, not simple commodities. They resemble closed-source providers (Windows, macOS) and open-source alternatives (Linux). The Llama ecosystem is presented as a potential open-source equivalent for LLMs. Analogy LLM Equivalent Explanation Electricity Grid LLM training and API access Capex for training, opex for API access, demand for reliability and quality. Semiconductor Fab LLM training infrastructure and models High capital expenditure for training, deep tech tree and R&D. Operating System The LLM itself and its surrounding ecosystem Complex software ecosystem with closed-source and open-source options, similar to Windows/macOS and Linux. Karpathy emphasizes that LLMs are in their early stages, akin to the 1960s era of computing, with expensive compute power leading to centralized cloud-based access. The potential for personal computing with LLMs is explored, with Mac Minis highlighted as a possible platform. A unique aspect of LLMs is their reversed technology diffusion: unlike most technologies initially adopted by governments and corporations, LLMs are first embraced by consumers. The Psychology of LLMs Karpathy describes LLMs as stochastic simulations of people , highlighting their strengths and weaknesses: Strengths: Encyclopedic knowledge and memory, surpassing human capabilities. Weaknesses: Hallucinations (making up facts), lack of self-awareness, jagged intelligence (superhuman in some areas, flawed in others), and retrograde amnesia (inability to consolidate knowledge over time). The analogy to the movie Rain Man illustrates the impressive memory capabilities of LLMs, while Memento and 50 First Dates highlight their limitations in knowledge retention and context management. Security concerns, such as gullibility and prompt injection risks, are also mentioned. Opportunities: Partial Autonomy Apps Karpathy discusses the potential of partially autonomous apps leveraging LLMs: Context Management: LLMs handle significant context management. Orchestration: LLMs orchestrate multiple calls to different models (embeddings, chat models, diff applications). Application-Specific GUIs: Custom GUIs are crucial for human auditing and efficient interaction. They facilitate faster verification of LLM outputs. Autonomy Slider: Users control the level of autonomy, ranging from minimal assistance to full agent control. Examples include Cursor (AI-assisted coding) and Perplexity (AI-powered research). The importance of designing for human-AI cooperation, where humans verify AI-generated outputs, is emphasized. Speeding up the verification process through GUIs and keeping the AI "on a leash" (avoiding overly large or uncontrolled outputs) are key strategies. Vibe Coding and the Democratization of Programming The ability to program LLMs in natural language democratizes software development. "Vibe coding" is presented as a new approach, allowing even non-programmers to create simple applications. Karpathy shares his experiences building an iOS app and a menu image generation app ("Menu Gen") using vibe coding, highlighting the ease of prototyping but the challenges of integrating real-world features (authentication, payments, deployment). He points out that the non-coding aspects (DevOps, integrations) can be significantly more time-consuming than the actual coding. Building for Agents: A New Software Infrastructure Karpathy argues for building software directly for LLMs (agents), rather than adapting existing human-centric interfaces. This includes: Agent-Friendly Documentation: Replacing human-oriented instructions ("click this") with agent-executable commands (e.g., curl commands). Examples include Vercel and Stripe adopting this approach. LLM-Friendly Data Ingestion: Tools that transform data into formats easily processed by LLMs (e.g., get-ingest , deep-wiki ). Model Context Protocol: Standardized protocols for direct communication with agents. The goal is to create a smoother interaction between LLMs and software, reducing the friction and cost associated with adapting existing systems. While acknowledging that some software will remain human-centric, Karpathy advocates for meeting LLMs halfway to facilitate more efficient interactions. Key Takeaways Karpathy's talk emphasizes the profound impact of LLMs on software development. The shift from Software 1.0 to 3.0 necessitates a rethinking of software design, development, and interaction. Building partially autonomous apps with user-friendly GUIs and well-defined autonomy sliders is crucial. Furthermore, creating software infrastructure that caters to the unique capabilities and limitations of LLMs is essential for unlocking their full potential. The democratization of programming through natural language interfaces opens exciting possibilities, but also presents challenges that require careful consideration.