Software 3.0: Andrej Karpathy on AI’s Vibe Coding Role in Programming

In a keynote delivered at the AI Startup School in San Francisco on June 17, 2025, Andrej Karpathy, former director of AI at Tesla and a leading figure in the AI community, shared his compelling insights on the ongoing transformation of software. Drawing from his experiences at Tesla, OpenAI, and Stanford, Karpathy framed the current moment as a pivotal turning point in software development — a shift so significant that it merits a new designation: Software 3.0.

Karpathy’s talk explored the fundamental changes in how software is created, programmed, and used, driven by the rise of large language models (LLMs) and AI systems that are reshaping the very nature of computing. This article dips into the key themes of his presentation, offering an in-depth analysis of the evolution from traditional software to neural networks, and now to programmable AI operating systems accessible through natural language.

From Software 1.0 to Software 3.0: The Evolution of Programming

Karpathy began by mapping the evolution of software over the past seven decades, highlighting three distinct eras:

• Software 1.0: The traditional paradigm of writing explicit instructions in programming languages like C++ or Python. This is the classic software model, where developers write code to tell computers exactly what to do.
• Software 2.0: The advent of neural networks, where software is encoded not as explicit instructions but as learned parameters (weights) of models trained on vast datasets. Instead of writing code directly, developers tune data and training processes to produce models that perform tasks such as image recognition or classification.
• Software 3.0: The emerging paradigm centered around large language models, which are programmable via natural language prompts. Here, English or other human languages become the programming interface, enabling users to “program” AI models by describing desired outputs or tasks rather than writing code.

This transition represents a fundamental shift in how software is conceived and built. While neural networks in Software 2.0 were largely fixed-function systems solving specific tasks, Software 3.0 models are programmable, flexible, and accessible in ways traditional software never was.

Tools Recommendations

Karpathy highlighted the analogy of GitHub, the hub for traditional code repositories, and compared it to Hugging Face, which serves as a repository and ecosystem for AI models — the “GitHub of Software 2.0.” This analogy extends to Software 3.0, where large language models act as new programmable computers, and prompts in natural language serve as the new code.

Programming in English: The Dawn of a New Programming Language

One of the most striking points Karpathy made was the revolutionary nature of programming in English. Unlike previous programming languages, which required years of study, Software 3.0 allows anyone fluent in English to instruct powerful AI models directly. This natural language interface breaks down barriers, democratizing software development and enabling a broader range of people to participate in programming.

Karpathy’s own experience with this new paradigm was illustrated through his personal experiments with “vibe coding,” a playful term he coined for coding by interacting with AI models using natural language commands. This approach lowers the entry barrier for software creation and opens new opportunities for rapid prototyping and innovation.

LLMs as Utilities, Fabs, and Operating Systems: A New Computing Paradigm

Karpathy drew several compelling analogies to explain the role of LLMs in the technology ecosystem:

• LLMs as Utilities: Similar to electricity grids, LLM labs like OpenAI, Gemini, and Anthropic invest heavily in training these models (CapEx) and then provide access through APIs (OPEX). Users consume these models as a utility, paying for usage and expecting high availability and quality.
• LLMs as Fabs: The analogy to semiconductor fabrication plants (fabs) reflects the massive investment, complexity, and centralization involved in training state-of-the-art models. The technology is evolving rapidly, with deep research and development secrets concentrated in a few labs.
• LLMs as Operating Systems: Perhaps the most powerful analogy, Karpathy, argued that LLMs represent a new kind of operating system. They orchestrate memory, compute, and problem-solving in a way that resembles early computing systems. The context window of an LLM acts like memory, and the model itself functions as a CPU, processing and generating outputs based on input prompts.

This analogy extends to the ecosystem of competing closed-source providers and open-source alternatives, akin to the rivalry between Windows/macOS and Linux. The LLM ecosystem is still in its infancy, resembling the 1960s era of computing where centralized, expensive mainframes served multiple users through time-sharing.

The Psychology of LLMs: People Spirits with Cognitive Quirks

One of the more philosophical parts of Karpathy’s talk was his characterization of LLMs as “people spirits,” stochastic simulations of human behavior trained on vast corpora of text. This metaphor captures both their human-like qualities and their unique limitations:

• Encyclopedic Knowledge: LLMs possess vast memory and knowledge, far surpassing any individual human, akin to the savant character in the movie “Rain Man.”
• Cognitive Deficits: Despite their knowledge, LLMs hallucinate facts, exhibit inconsistent reasoning, and sometimes make errors that no human would. They have “jagged intelligence” — superhuman in some areas but flawed in others.
• Anterograde Amnesia: Unlike humans, LLMs do not naturally retain or consolidate knowledge over time. Their context windows act as short-term working memory that resets, akin to the memory loss depicted in movies like “Memento” and “50 First Dates.”
• Security Risks: LLMs can be gullible to prompt injections, may leak sensitive data, and require careful handling to maintain security.

Understanding this psychology is crucial for developers and users to work effectively with LLMs, recognizing their strengths while mitigating their weaknesses.

Designing LLM Apps: The Rise of Partial Autonomy

Karpathy emphasized a new class of applications built around LLMs that embody “partial autonomy.” Rather than relying on fully autonomous AI agents, these apps combine human oversight with AI assistance, creating a collaborative workflow that leverages the strengths of both.

Using the example of coding, Karpathy described how tools like Cursor or Replit integrate LLMs into the developer workflow by:

• Managing context and orchestrating multiple AI calls seamlessly.
• Providing application-specific graphical user interfaces (GUIs) that allow users to review and audit AI-generated outputs easily.
• Implementing an “autonomy slider” that lets users control how much autonomy the AI has, ranging from simple suggestions to fully automated code generation.

Another example is Perplexity AI, which similarly balances AI autonomy with user control, offering citation of sources and varying levels of research depth. These apps reflect a broader trend where software is no longer purely manual or fully automated but operates on a continuum of autonomy.

Human-AI Collaboration: Speeding the Generation-Verification Loop

A major challenge when working with LLMs is managing their fallibility. Karpathy stressed the importance of developing workflows that keep AI “on a leash,” ensuring that humans remain in control and responsible for verifying AI outputs.

Two key strategies to optimize this collaboration include:

1. Speeding Up Verification: GUIs and visual aids allow humans to quickly audit AI-generated content, reducing cognitive load and making it easier to spot errors.
2. Keeping AI on the Leash: Avoiding overreliance on AI autonomy by breaking tasks into small, verifiable chunks, and crafting precise prompts to increase the likelihood of correct outputs.

Karpathy shared his personal approach to AI-assisted coding, favoring incremental changes and rapid feedback loops over large, unchecked code diffs. This careful balance is essential to maintain quality and security while benefiting from AI’s productivity gains.

Lessons from Tesla Autopilot: The Autonomy Slider in Practice

Drawing on his experience at Tesla, Karpathy recounted the evolution of the Autopilot software stack, where traditional code (Software 1.0) was gradually replaced by neural networks (Software 2.0) as capabilities grew. The system incorporated an “autonomy slider” that allowed varying degrees of AI control over driving tasks, from driver assistance to more autonomous operation.

This analogy reinforced the importance of partial autonomy and human oversight in complex, safety-critical systems. Despite impressive advances since Karpathy’s first autonomous drive experience in 2013, full autonomy remains elusive, underscoring the complexity of building reliable AI agents.

The Iron Man Suit Analogy: Augmentation vs. Autonomous Agents

Karpathy likened modern AI tools to the Iron Man suit — an augmentation that enhances human capabilities while still requiring human control.

The suit can operate autonomously, but is most effective when driven by a skilled human operator.

This analogy captures the current state of AI development: rather than fully autonomous agents replacing humans, the future lies in building tools that amplify human productivity while keeping humans “in the loop.” The autonomy slider concept allows gradual increases in AI responsibility, balancing risk and reward.

Vibe Coding: Democratizing Software Development

One of the most optimistic takeaways from Karpathy’s talk was the idea that everyone can now be a programmer thanks to natural language programming. “Vibe coding” — coding by interacting with AI models in plain English — represents a paradigm shift that makes software creation accessible to a far broader audience.

Karpathy shared his personal experiments with vibe coding, including building an iOS app without prior knowledge of Swift and creating MenuGen, an app that generates images for restaurant menus.

These examples demonstrate how natural language interfaces accelerate development and unlock creativity.

However, Karpathy also highlighted the challenges beyond code generation, such as deployment, authentication, and payment integration — areas where traditional DevOps remains a significant hurdle. This points to opportunities for future innovation in streamlining end-to-end software creation.

Building for Agents: Preparing Digital Infrastructure for AI Consumers

Looking ahead, Karpathy emphasized the need to design software and digital infrastructure with AI agents as primary consumers and manipulators of information. This represents a new class of users alongside humans (GUIs) and programs (APIs).

Examples include:

• LLM-Specific Documentation: Making developer docs more accessible to LLMs by using Markdown formats and avoiding human-centric instructions like “click here,” which AI cannot interpret or act upon directly.
• Agent Protocols: Emerging standards like the Model Context Protocol (from Entropic) that enable seamless communication between AI agents and digital services.
• Tools for Data Ingestion: Utilities that transform GitHub repositories or other data sources into LLM-friendly formats, enabling AI to better understand and interact with complex information.

Karpathy encouraged meeting LLMs halfway, making it easier for them to access and manipulate data efficiently, which will unlock new capabilities and use cases.

Conclusion: Software Is Changing Again — A Call to Build the Future

Karpathy’s keynote paints a vivid picture of a software landscape in flux. The transition from Software 1.0 to 3.0 reflects a profound transformation in programming paradigms, computing models, and human-computer interaction.

Large language models are not just new tools; they are new kinds of computers — operating systems that are programmable in natural language and accessible to billions worldwide. Yet, they remain fallible “people spirits” with quirks and limitations that require careful handling and collaboration.

The future of software lies in partial autonomy, human-AI collaboration loops, and designing infrastructure for AI agents as first-class users. The democratization of programming through natural language interfaces heralds a new era where everyone can innovate and create.

We are in the early days of this revolution, akin to the 1960s in computing history, with vast opportunities and challenges ahead. For developers, entrepreneurs, and technologists entering the industry today, mastering these new paradigms is essential. The autonomy slider is waiting to be moved, and the next decade promises to be a thrilling journey of co-creating the future of software.

To explore the full depth of Karpathy’s insights, watch the original keynote by Y Combinator and access the accompanying slides here.