Software 3.0: A New Paradigm

He Invented Vibe Coding, Now He Defends Something Else

“I have never felt this far behind.”

Andrej Karpathy says this. He was one of the founders of OpenAI. He built Tesla’s self-driving software. Last year, he shook the whole industry with the idea of “vibe coding.”

And honestly, I feel the same way. I have been saying this a lot in recent months. The tools are growing so fast. It is hard not just to keep up, but even to follow what is new.

Karpathy is not really complaining. He is showing his surprise at how fast the tools and models are moving forward. Behind this surprise, there is a much bigger paradigm.

Three paradigms, one revolution

To understand Karpathy, we first need to understand the way he thinks. When he wrote the “Software 2.0” article in 2017, the industry did not take him seriously. Then everyone saw what it meant in Tesla’s systems: hundreds of thousands of lines of hand-written rules were turning into a neural network. And the results were much better.

Now it is time for the third version.

Software 1.0 is the world we all know. You write code, the computer runs it. Every step is clear, deterministic, and predictable. It is strong but fragile: you have to define every situation in advance.

In Software 2.0, you do not write the rules; the data writes them. You design neural networks, prepare data sets, and define the goal function. Optimization handles the rest. The meaning of the word “programming” quietly changed: it became shaping behavior, not writing code.

Software 3.0 is what we are living in right now. Large language models have become a software development platform. You do not need code or data sets anymore; natural language is enough. What is in the context window is your data set, the prompt is your program, and the LLM is your interpreter.

Notice that these three paradigms do not replace each other; they are added on top of each other. A system you run today probably has all three at the same time. But the process under 3.0 is getting faster.

December 2025: The breaking point

Karpathy likes to explain abstract ideas with real stories. And the story that shows this change most clearly is his own experience.

During 2025, he was using tools like Claude Code and Codex. They were helpful, but he often needed to fix things. Then December came. He was on holiday and had more time than usual. He noticed something: the models were now producing bigger parts, working in a more consistent way, and making fewer mistakes. “I cannot remember the last time I had to fix something,” he said. His trust in the system started to grow. His side-project folder exploded.

He is not sharing this only as a personal observation. “Many people missed this change. A lot of people still think of AI as something like ChatGPT from last year. But from December on, things have changed deeply,” he says.

From vibe coding to agent engineering

This is where Karpathy’s most important difference appears.

Vibe coding made the work easier. Now someone without technical knowledge can also write an application, build a prototype, and quickly test an idea. All of these are real and valuable.

But staying in vibe coding is the same as staying stuck in the old paradigm.

“Agent engineering” really changes things. Give the work to agents, but keep the quality high. Do not allow security holes. Design the system correctly. Karpathy gives a real mistake from his own project: the agent wrote code that used the same email addresses to match Stripe payments with Google accounts. The code was working. But the design was wrong. Because someone can use one email on Stripe and a different one on Google. Seeing this mistake needs human judgment.

It is not about knowing how to code, but understanding what is right.

Ghosts, not animals

Karpathy’s most original metaphor comes here. He says it is wrong to think of LLMs as animals. Animals were shaped by evolution; they have curiosity, play, and inner motivation. LLMs do not have any of these. They are statistical structures pulled from billions of pieces of human-made data. They look familiar because they speak our language. But inside, there is no animal mind, only statistics.

Karpathy calls them “ghosts.” And this metaphor is important. If you treat them like animals, you will be disappointed. LLMs are “jagged” beings. They can rewrite 100,000 lines of code, but they can give the wrong answer about whether you should walk or drive to a car wash 50 meters away. This inconsistency is not a bug; it is in the nature of these systems.

You need to learn from experience where the model is strong and where it stumbles. Blind trust and blind doubt are both wrong.

Understanding cannot be delegated

A sentence that stays in Karpathy’s mind explains many things: “You can delegate thinking, but you cannot delegate understanding.” You can leave the process to the agent, but you cannot leave the understanding.

No matter how strong agents become, direction stays with the human. Knowing what to build. Understanding why it is valuable. Sensing when the model is going the wrong way. Noticing which result is suspicious.

This is not a prize for losing. According to Karpathy, this is the rarest resource of the coming period. Producing code is getting cheaper, and memorizing API details is becoming meaningless. But understanding, judgment, and taste are becoming more and more valuable.

Feeling behind is not a complaint, but a warning. The paradigm has changed, and the question you need to answer is this: Are you changing too?