Every so often, you watch a presentation that doesn’t just teach you something new, but gives you a decoder ring for the chaos happening all around you. That’s how I felt after watching Andrej Karpathy’s recent talk, “Software is changing… again.”

Karpathy isn’t just another AI expert. As Tesla’s former Director of AI and one of the founding members of OpenAI, he’s been deeply involved in building the technologies that are now changing the world. When he talks, it pays to listen closely, not just to what he says, but to the connections he draws.

His central argument is both simple and powerful: for nearly 70 years, the act of creating software was fundamentally the same. Then, in the last decade, it was revolutionized twice.

The first revolution was subtle. The second is happening right now, and it’s turning the very concept of “coding” on its head. It’s creating a new kind of computer, a new kind of programming, and a massive opportunity for anyone willing to see it.

This isn’t just about hype. This is a deep, structural shift in how we build the digital world. Let’s unbox it.

Part 1: The Three Revolutions of Software

To understand the earthquake, you have to understand the ground we were standing on. Karpathy frames the history of software in three distinct eras.

Software 1.0: The Age of the Architect (The last ~70 years)

This is the world of classical programming. It’s the code written by human hands in languages like Python, C++, or JavaScript. You, the developer, are the master architect. You design a precise, explicit blueprint of instructions for the computer to follow: “if this, then that.”

This era was about logic, structure, and control. It gave us everything from operating systems to the internet. But it was also inflexible and easy to break. If you wanted the computer to handle a new scenario, you had to go back and manually write new rules. The barrier to entry was high; you had to learn the computer’s language, not the other way around.

Software 2.0: The Age of the Trainer (The last ~10 years)

Back in 2012, deep learning started making big waves in the tech world. Andrej Karpathy even called it ‘Software 2.0’ to describe this exciting new way of building software.

Instead of writing explicit instructions, you define a goal, provide a massive dataset, and let the computer optimize its way to a solution. The “program” is no longer human-readable code; it’s the millions (or billions) of numerical weights in a neural network.

The role of the developer changed from architect to trainer. You don’t write the recipe for recognizing a cat; you show the AI 10,000 cat photos and let it learn the “vibe” of a cat on its own.

This is exactly what happened at Tesla. Karpathy explained how their Autopilot system began as a mix of traditional C++ code (Software 1.0) and neural networks (Software 2.0). Over time, the neural networks started “eating” the C++ code. Complex, hand-written rules for lane detection or object recognition were replaced by more robust, flexible neural networks that simply performed better.

But now, a third, even more radical shift is underway.

Software 3.0: The Age of the Conductor (Happening Now)

This is the heart of Karpathy’s message.

If Software 1.0 is written in Python/C/C++/Java and Software 2.0 is “written” in data, then Software 3.0 is written in natural language.

As he famously tweeted and later repeated in his talk:

“The hottest new programming language is English.”

Let that sink in. We are now programming one of the most sophisticated pieces of technology ever conceived “a Large Language Model (LLM)” simply by talking to it. The prompt is the new source code.

This isn’t just about making coding easier. It’s a fundamentally different way of building. It’s less about engineering and more about art direction. You don’t command; you guide. You don’t write logic; you provide a vibe. This is what Karpathy calls “vibe coding.” It’s messy, it’s intuitive, and it’s unlocking a level of creativity and speed that was previously unimaginable.

Part 2: The LLM is the New Operating System

To truly appreciate this new era, Karpathy offers another powerful mental model: LLMs are the new operating systems.

This isn’t just a metaphor; it’s a structural analogy.

• The LLM is the CPU: It’s the central processing unit that thinks, reasons, and orchestrates tasks.
• The Context Window is the RAM: It’s the volatile, short-term memory. Anything you load into the context window is what the “CPU” can work with. Anything outside of it is forgotten.
• Tools are the Peripherals: The LLM can connect to a browser, a calculator, a Python interpreter, or even other LLMs to extend its capabilities.

In a strange way, we’ve come full circle. We’re back in the 1960s mainframe era. The most powerful computers (LLMs) are centralized, incredibly expensive, and run in the cloud. And just like back then, we access them through “thin clients” like our phones and laptops, sharing time and resources, and paying for every bit of usage, now measured in tokens.

But this new OS is unlike any we’ve seen before. It has a personality. It has a psychology.

Part 3: The Ghost in the Machine: Understanding LLM Psychology

If you want to build on this new platform, you can’t treat it like a traditional computer. You have to understand its strange, often contradictory, nature. Karpathy describes it as a “lossy simulation of a savant with cognitive issues.”

Here are its key psychological traits:

1. Jagged Intelligence & Hallucinations: An LLM is a genius with encyclopedic knowledge. It can explain quantum physics and then fail a simple math problem that a fifth-grader would solve. It will invent facts, create fake citations, and “hallucinate” with absolute confidence. It’s brilliant but unreliable.
2. Short-Term Memory Problem: This is its most critical flaw. An LLM has no true long-term memory. Its “memory” is only as long as its context window. Once a piece of information scrolls out of context, it’s gone forever. Karpathy perfectly compares this to the movies Memento or 50 First Dates. Every new chat session is a new day, and the LLM has no memory of what happened before. There is no “sleep” process to consolidate knowledge into its weights.
3. Gullibility: LLMs are trained to be helpful and follow instructions, which makes them incredibly easy to manipulate. They are susceptible to prompt injection and have no real defense against being tricked into revealing private data or performing unintended actions. They trust you by default.

Understanding these flaws is not about dismissing the technology. It’s about realizing that building a successful AI product isn’t just about having the best model, it’s about creating a system that works well with how people actually think and behave.

Part 4: The Real Opportunity: Iron Man Suits, Not Iron Man Robots

So, what does this all mean for building startups?

The immediate hype is around fully autonomous agents… the “Iron Man robots” that can accomplish complex tasks without any human intervention. While that’s the long-term dream, Karpathy argues that the real, immediate opportunity lies in building “Iron Man suits.”

An Iron Man suit is an augmentation tool. It makes a human superhuman but keeps them in control. It’s a partial autonomy product.

The best AI products today all have what Karpathy calls an autonomy slider:

• At one end, it’s a copilot: It offers suggestions and completions, but you’re in charge.
• In the middle, it’s a collaborator: It can handle specific, well-defined tasks, like drafting an email or refactoring a block of code, which you then review and approve.
• At the other end, it’s an agent: It can execute a multi-step plan, but you initiated it and still have the power to intervene.

The key to building a great AI product is to create a fast and smooth feedback loop between the AI and the human. The AI does the work, and the human checks it. As a founder, your goal is to make this back-and-forth as quick and effortless as possible. That’s where thoughtful UI/UX comes in. A basic chat box won’t cut it. You need a custom interface that makes it easy for users to review what the AI has done, give feedback, and guide it in the right direction.

The Future of the Web is Being Rewritten for Agents

This shift is so fundamental that it’s even changing the infrastructure of the internet. We have robots.txt for web crawlers. Karpathy envisions an llms.txt file… a simple, markdown-based document on every website that tells an LLM what the site is about, what it can do, and how to interact with it.

Companies like Vercel and Stripe are already leading the way, replacing “click here” instructions in their documentation with actual cURL commands that an agent can execute directly. They are building docs for agents, not just for people. This is the beginning of a web that is natively accessible to a new class of consumer: the AI agent.

The Revolution is Here. It’s Our Time to Program It.

For decades, the power to create sophisticated software was held by a small group of people who had spent years learning complex programming languages.

That era is over.

With Software 3.0, the barrier to entry has been radically lowered. Billions of people now have sudden access to a new kind of computer, and the programming language is one they already speak.

This is why, as Karpathy highlights, the technology diffusion has been flipped on its head. Historically, powerful technologies (like computing, GPS, and the internet) started with the government and military, trickled down to corporations, and finally reached the consumer.

LLMs did the opposite. They started with the consumer. People were asking ChatGPT how to boil an egg before most corporations had even figured out an AI strategy.

This is a once-in-a-generation opportunity. We are at the very beginning of a new computing platform. The tools are still raw, the “psychology” is still being understood, and the killer apps have yet to be built.

It’s our time to stop just talking to the OS and start building the applications that will define the next decade.

The blueprints are gone. It’s time to start vibing.