Andrej Karpathy's viral speech has swept through the tech circle: AI ushers in Software 3.0, and the era of rewriting everything has arrived.

Editor's Note: Recently, on the podium of the AI Startup School in San Francisco, Andrej Karpathy, an AI leader who has worked at Stanford University, OpenAI, and Tesla, revealed a paradigm shift that is reshaping the technological world from a unique perspective spanning academia and industry. Andrej has witnessed a "programming revolution" taking place. With the development of AI technology, software programming has entered the "3.0 era," where natural language has replaced traditional code as the core programming interface, and large models undertake the complex logic that previously required manual coding. Andrej pointed out that this transformation is far from a simple tool iteration. When developers can drive the system through daily language instructions and when users' needs can be directly translated into machine-executable intentions, we are essentially building a "new type of computer." This computer no longer relies on precise grammatical rules but understands the world in a probabilistic and semantic way, just like humans. This evolution is a good thing for developers, as it means the elimination of the programming threshold. It is even better for users because it can completely liberate the interaction mode, and there will no longer be language barriers in human-machine collaboration. As Andrej emphasized, we are standing at a historical turning point in human-machine relations. In the future, software will no longer be a cold tool but an intelligent partner that can understand, reason, and even actively collaborate. The depth of this change may be no less than the leap from the command line to the graphical interface back then.

The following content is compiled by InfoQ based on the video of Andrej Karpathy's on-site sharing, with the original meaning maintained.

AI has disrupted traditional software components

I'm very glad to be here today to talk to you about "Software in the AI Era." I heard that many of you here are undergraduate, master's, or doctoral students, getting ready to enter this industry. Now is a very unique and interesting time to enter this field.

Why do I say so? Because I believe that software today is undergoing another profound change. Notice that I used the word "another" here because I actually gave a similar speech before. Then why am I giving a speech on this topic again? Because software is constantly changing, so I can always find new materials for new speeches. And this time, the change, I think, is very fundamental.

Generally speaking, software has not changed much in essence in the past 70 years, but in recent years, it has experienced two major changes. Therefore, we have a lot of work to do - a large amount of software needs to be rewritten or redesigned.

Let's shift our perspective to the realm of software. If we regard it (Map of GitHub) as a software map, it shows all the software code we have written, which are various instructions that allow computers to perform tasks in the digital space.

When you zoom in, you can see that each small dot is actually a different code repository, which is already written code.

A few years ago, I began to realize that software was changing, and a "new type of software" was emerging. At that time, I called it "Software 2.0".

Software 1.0 is the code we traditionally write for computers. Software 2.0, in essence, is the weights of neural networks. Instead of writing code directly, you train the parameters of neural networks by adjusting the dataset and running the optimizer. At that time, many people regarded neural networks as classifiers like decision trees, nothing special. But my view at that time was that this was actually a new software paradigm.

Now, in the era of Software 2.0, something similar to "GitHub" is also emerging. For example, Hugging Face is basically the GitHub of the Software 2.0 era. There are also visualization tools like Model Atlas, which can show the parameters of various models. For instance, the large circle in the middle is the parameter point of the image generation model FLUX. Every time someone fine-tunes a new model based on FLUX, it's actually like "submitting a git commit" on this graph, essentially generating a new version of the image generator.

So we can understand it as follows:

• Software 1.0 is the code written for computers
• Software 2.0 is the weight parameters written for neural networks

For example, AlexNet is an image recognition neural network.

Most of the neural networks we are familiar with in the past were "fixed-value function" type computers. For example, you input an image, and it outputs a category label. But recently, a fundamental change has occurred, that is: neural networks have become "programmable," thanks to large language models (LLMs). So I think this is a whole new computer world.

So this new era deserves to be called Software 3.0: You no longer write code or train neural network parameters, but directly "program" the LLM through "Prompts." Even better, this programming language is the "English" we use in our daily lives.

This is really interesting. Let's use an example to illustrate the difference between the Software 3.0 era and other programming methods:

Suppose you want to do sentiment classification. In the Software 1.0 era, you need to write a Python code. In the 2.0 era, you need to train a neural network. And now, many GitHub codes are not just codes anymore. You can directly write a Prompt in English to let the large language model output the classification results.

This is actually a brand-new programming method, and it is done in natural language.

A few years ago, when I realized this, I posted a tweet, and many people noticed this change because of it. This tweet is still my pinned post: Now we can program computers in English.

I was involved in the development of the autonomous driving system at Tesla. We tried to make the car drive autonomously and showed an architecture diagram at that time.

The diagram shows that the input comes from various sensors (such as cameras), goes through a series of software processing, and finally outputs the steering wheel angle and acceleration.

At that time, I pointed out that there was about "a ton" of C++ code in the system, which was Software 1.0, and at the same time, some neural networks for image recognition began to appear. This change is very interesting. As the performance of the autonomous driving system improves, the scale and capabilities of the neural networks are getting stronger and stronger. At the same time, we began to gradually delete a large amount of logical code originally written in C++.

Operations like "stitching together multi-camera images" are now handed over to neural networks. As a result, we deleted a large amount of 1.0 code. It can be said that the Software 2.0 stack has "devoured" the Software 1.0 stack and become the main part of the system.

Now, we are experiencing the same thing. The new software paradigm (Software 3.0) is rapidly permeating the entire technology stack. We now have three completely different programming paradigms in front of us: 1.0, 2.0, and 3.0.

If you are about to enter this industry, I suggest you be very familiar with all three. They each have their own advantages and disadvantages. Some functions may be suitable for writing code directly (1.0), some are suitable for training neural networks (2.0), and some only need to write a Prompt (3.0). We will constantly face such a choice: Which way should we use to implement this function? Should we train a model? Can we just let the LLM generate the answer?

AI is becoming the new electricity

And we must also have the ability to switch flexibly among these three paradigms.

Next, I'd like to move on to the first part of this sharing...

Large language models (LLMs) have the characteristics of public infrastructure, foundries, and operating systems. They are becoming a new type of "operating system," built by major laboratories and distributed like public utilities (for now). Many historical analogies apply. In my opinion, our current computing level is roughly equivalent to that of the 1960s.

Regarding LLMs, how to understand this new paradigm and ecosystem, and what it looks like, I'd like to quote a statement made by Andrew many years ago. He should be speaking after me. He said at that time, "AI is the new electricity."

I think this statement is very inspiring, as it really captures a key point: LLMs obviously have the attributes similar to "public utilities."

Current LLM laboratories, such as OpenAI, Gemini, Anthropic, etc., will invest a large amount of capital expenditure (CapEx) to train LLMs, which is like building a power network. Then, they need to "supply" the intelligent capabilities to all of us through APIs, which is the operating expenditure (OpEx). We pay for access based on the price per million tokens. This model is essentially like the demand for public utilities: we require low latency, high availability, and stable service quality.

In the power system, there are "switches" that can switch between the mains, solar energy, batteries, or generators. In the world of LLMs, we also have mechanisms like "open routers" that can easily switch between multiple LLM providers. Since LLMs are software, they do not directly compete in the physical space, and you can use multiple "power suppliers" simultaneously. This is very interesting.

A few days ago, we saw several LLMs malfunction, and people suddenly couldn't work properly. We have gradually become so dependent on them that once the most advanced LLMs "go down," it's like a "smart power outage," and it's as if society has become "stupid" when the grid voltage is unstable. The more we rely on these models, the more obvious this impact will be.

However, LLMs are not just like "public utilities." They are also a bit like "foundries." The capital expenditure required to train LLMs