Andrej Karpathy: Software in the Era of AI

I wanted to share a great AI-related video that I came across.
This is a keynote speech by Andrej Karpathy from the AI Startup School held in San Francisco on June 17, 2025.

He does an excellent job explaining how AI is becoming mainstream, using clear examples throughout his presentation.
The content isn’t too technical, which makes it quite accessible. For those who haven’t seen it yet, I’d recommend checking it out when you have some time.

Below is a summary of the video content that I’ve organized using AI. Take a look at this first — it should make watching the actual video much easier to follow.

Summary of Andrej Karpathy’s Talk: Software in the Era of AI

Andrej Karpathy argues that we are currently in the most exciting and interesting time to enter the software industry. The reason, he explains, is a fundamental shift in the software paradigm itself. He breaks down the evolution of software into three distinct stages.

1. The Fundamental Shift in Software: 1.0, 2.0, and 3.0

For the first time in roughly 70 years, the way we create software is undergoing a radical change. Karpathy insists that developers must now be fluent in all three paradigms to build effectively.

• Software 1.0 (Classical Code)
• This is the traditional code we are all familiar with, written in languages like Python or C++.
• It operates based on explicit instructions written by a human programmer.
• Software 2.0 (Neural Networks)
• In this paradigm, the code is the weights of the neural network.
• Instead of writing explicit instructions, developers curate datasets and use optimizers to let the computer “write” the code (the weights) for itself.
• He compares Hugging Face to the “GitHub of Software 2.0.”
• Software 3.0 (Large Language Models — LLMs)
• This is the newest paradigm where the prompt you provide to an LLM is the program.
• Its most revolutionary feature is that the programming language is a natural language, like English.
• This represents the dawn of a completely new way of programming.

Key takeaway: Just as C++ code (1.0) was progressively replaced by neural networks (2.0) in Tesla’s Autopilot, we are now seeing a similar shift where existing software stacks are being replaced by LLMs (3.0).

2. What is an LLM? (A New Computer and Operating System)

Karpathy urges us to see LLMs not just as a technology, but as an entirely new computing platform, offering several analogies.

• Similar to a Utility (like electricity) or a Fab (semiconductor factory):
• They require immense upfront capital expenditure (Capex) to train, and we access them via APIs on a pay-per-use basis (Opex), similar to electricity.
• Our reliance is growing so much that when a major LLM goes down, it triggers a global “intelligence brownout.”
• The Best Analogy: An Operating System (OS):
• He argues that LLMs are like the centralized, mainframe computer operating systems of the 1960s.
• The LLM = CPU, and the Context Window = RAM.
• We are all using “time-sharing” to access these expensive computers in the cloud. The “Personal Computing (PC)” revolution for LLMs has not happened yet.
• Interacting with ChatGPT via text is like using a terminal; a universal, user-friendly GUI has yet to be invented.

A Unique Phenomenon: Unlike past technologies (computers, internet) that diffused from government/corporate sectors to consumers, LLMs have flipped this pattern. Everyday consumers were the first to benefit — asking how to boil an egg — while corporations and governments are now playing catch-up.

3. How to Work with LLMs (Superpowers and Cognitive Deficits)

Karpathy describes LLMs as “stochastic simulations of people,” and to work with them effectively, we must understand their “psychology.”

• Superpowers: They possess encyclopedic knowledge and near-perfect recall, much like the autistic savant in the movie Rain Man.
• Cognitive Deficits:
• Hallucination: They confidently invent facts.
• Jagged Intelligence: They can be superhuman in one domain but make absurd mistakes in another (e.g., insisting “strawberry” has two ‘r’s).
• Anterograde Amnesia: They do not learn or grow from interactions. Their “weights are fixed,” and the context window (working memory) is wiped clean after each session. He compares this to the movies Memento and 50 First Dates.
• Security Risks: They are gullible and susceptible to prompt injection.

4. Opportunities in the LLM Era: “Partial Autonomy” and the “Iron Man Suit”

Despite their flaws, LLMs present immense opportunities. Karpathy emphasizes that we should focus on creating products with “partial autonomy” rather than chasing fully autonomous agents.

• Partial Autonomy Apps:
• The core principle is to maximize the speed of the human-AI “Generation-Verification” loop.
• The AI generates work, and the human must be able to verify and correct it as quickly as possible.
• Hallmarks of a good LLM app (e.g., the coding tool ‘Cursor’):

1. Automated Context Management: Provides the LLM with relevant information automatically.
2. A Dedicated GUI: Speeds up human verification by presenting information visually (e.g., red/green diffs for code changes) instead of as plain text.
3. An “Autonomy Slider”: Allows the user to control the level of AI intervention, from simple auto-completion to rewriting an entire repository.

• “Keep the AI on a Leash”:
• If you let the AI generate a massive, complex output, the human becomes the bottleneck in reviewing it.
• It is far more efficient to assign small, incremental tasks and keep the verification loop spinning fast.

The Iron Man Suit Analogy: We should be building “Iron Man suits” (tools that augment human capabilities), not fully autonomous “Iron Man robots.” Our goal for the next decade is to gradually push the suit’s autonomy slider further to the right.

5. The Rise of New Programmers and “Building for Agents”

• “Vibe Coding”:
• Because the programming language is now natural language, anyone can create software based on a “vibe” or intuition, without deep technical knowledge.
• Everyone can now be a programmer. This dramatically lowers the barrier to entry for software development.
• Building Infrastructure for Agents:
• Karpathy notes that when building his own app, the coding was easy; the traditional DevOps (authentication, deployment, etc.) was the hard part.
• This is because our current digital infrastructure is designed for humans clicking through GUIs.
• We must now redesign our infrastructure for a new type of “user”: the AI agent.
• Create an llm.txt file on websites to explain the site structure to an AI.
• In documentation, replace “click here” instructions with executable API commands (curl) that an agent can use.

Conclusion

Karpathy concludes that this is an era of incredible opportunity to rewrite software from the ground up. The path forward is to build “Iron Man suit” products that enable “partial autonomy,” optimizing the collaborative loop between humans and AI. At the same time, we must evolve our digital infrastructure to be accessible not just to humans, but to the AI agents that will help us build the future.

This essay was originally published on Medium and migrated to KanApp Blog.