Let’s talk about the future of software, and trust me, it’s happening right now! I recently caught Andrej Karpathy’s keynote at AI Startup School in San Francisco, and wow, I had to share what I learned. Karpathy, who has previously worked at Tesla, OpenAI, and Stanford, gave us an insider look at Software 3.0, the next big evolution in programming.
So, what’s the big deal? Simple. The way we create software is shifting from writing lines of code to interacting with machines through natural language. If that sounds wild to you, it’s because it is! And in this post, I’m going to break it down for you.
Table of contents
The Evolution of Programming
Software 1.0: The Old School Coding
This was the traditional approach to programming. This is what most of us know as “coding”: where developers write explicit instructions in programming languages like Python, Java, or C++ to make a computer perform specific tasks. The process is straightforward: you tell the computer exactly what to do, step-by-step, in code. While this remains essential for many applications today, it has limitations in handling more complex tasks that require learning and adaptation.
Software 2.0: Enter Machine Learning
Machine learning entered the picture, and suddenly, we weren’t just writing code that told the computer what to do. Instead, we were training machines using data. This is where neural networks started to take over, allowing machines to learn from data and make decisions on their own. In Software 2.0, the goal wasn’t to tell the computer every little step. The goal was to teach it to figure out the steps on its own by recognizing patterns in the data. This led to groundbreaking progress in areas like image recognition, speech recognition, and natural language processing. However, this process still needed tons of coding to fine-tune the machine and get it working properly.
Software 3.0: Programming Through Natural Language
This is where we move beyond writing lines of code and start talking to machines. With Large Language Models (LLMs) like GPT-3, we no longer need to write code. Instead, we simply ask the machine to do what we want using natural language. It’s like having a conversation with your computer. You don’t have to know how to code to make a machine do complex tasks. You just speak (or type) your request, and the LLM takes care of the rest.
For instance, imagine you need to perform sentiment analysis. In Software 1.0, you would have to write algorithms to handle this. In Software 2.0, you would train a model to detect sentiment. But in Software 3.0, you simply tell the machine, “Analyze the sentiment of this text: ‘I love AI!’” And just like that, the machine understands, analyzes, and gives you the result.
With this evolution in mind, Karpathy segued into the next part of his keynote to discuss how LLMs fit into this new world of Software 3.0.
Part 1: How to Think About LLMs
Karpathy began by exploring how we should think about Large Language Models (LLMs), which are core to the shift to Software 3.0. He quoted Andrew Ng: “AI is the new electricity.” This quote underscores how LLMs are becoming a fundamental resource, much like electricity, and transforming how we interact with technology.
Here’s how Karpathy compared LLMs to utilities:
- CAPEX and OPEX: Karpathy explained that training an LLM requires significant capital expenditures (CAPEX), similar to building an electricity grid. Once trained, the model moves to operational expenditures (OPEX), where the LLM is served over APIs, similar to how electricity is distributed to homes.
- Metered Access: LLMs are now provided as services where you pay based on the amount of usage (e.g., cost per million tokens), similar to how electricity is billed based on consumption.
Karpathy also explained that LLMs have some characteristics of semiconductor fabrication plants (fabs), where the cost of building and training these models is huge. He compared companies like Google and xAI (which use massive GPU clusters) to traditional semiconductor manufacturers like Intel, who have their own fabs for training models on custom hardware (like TPUs).
Finally, Karpathy likened LLMs to operating systems. Traditionally, operating systems have been the foundation of software ecosystems, managing tasks and memory. Similarly, LLMs are becoming complex software ecosystems, the “core” of modern applications. These LLMs are no longer just simple tools; they are becoming integral to every part of software systems, similar to how an operating system controls and runs applications on a computer.
This marks a fundamental shift in how we develop software, no longer is it about lines of code, but interacting with these AI-powered systems that function almost like a new kind of computer.
Part 2: LLM Psychology
Next, Karpathy dove into the psychology of LLMs. He describes them as “people spirits.” What does that mean? Well, LLMs are built using autoregressive transformers, which means they simulate human-like behaviors—especially when it comes to language.
But just like humans, LLMs have some quirks and limitations. Let’s take a look:
- Hallucinations: LLMs can sometimes make mistakes that humans wouldn’t. For instance, they might say “9.11 > 9.9” or insist that there are two ‘r’s in strawberry. These are known as “hallucinations.” The model is generating incorrect information that sounds convincing but is totally wrong.
- Anterograde Amnesia: LLMs can’t remember things the way humans do. After a conversation ends, they forget everything. Unlike humans who learn and adapt over time, LLMs don’t consolidate knowledge between sessions.
- Gullibility: LLMs are vulnerable to being tricked by malicious prompts, leading them to give harmful or incorrect responses. This means that human supervision is crucial when working with these models.
Part 3: Opportunities in the Age of LLMs
Karpathy wrapped up his keynote by talking about the amazing opportunities brought by Software 3.0 and LLMs. One of the most exciting developments is the rise of partial autonomy apps. These apps let you automate tasks, but still give you control over the process.
Take Cursor, for example. It’s an app that lets developers interact with code using natural language. Instead of writing every line of code, you can ask the app to generate code, fix bugs, or review changes. It’s like having an AI-powered assistant do most of the work for you, making the development process much faster and easier.
Karpathy also introduced the autonomy slider: a feature that lets users decide how much control they want to give the LLM. For basic tasks, the LLM can take full control, but for more complex tasks, you can supervise the process.
LLMs also have huge potential in industries like education and AI-assisted coding. Imagine an AI tutor helping students learn or an AI assistant that helps developers write and debug code more efficiently. The possibilities are endless. Finally, Karpathy drew a parallel between autonomous agents like Tesla’s Autopilot and the future of autonomous software powered by LLMs. Moving from demos to reliable products takes time, but the future looks incredibly promising.
To know more, you can checkout his slides here.
Free Resources:
- A Guide to Master the Art of Vibe Coding
- Coding Made Easy with Canva Code
- Guide on Vibe Coding with Windsurf
- I Tried Vibe Coding with Cursor AI and It’s Amazing!
Conclusion
Karpathy ended his keynote with a powerful message: we’re entering the decade of agents. As LLMs continue to improve and become more accessible, they won’t just be tools, they will become agents capable of autonomous actions, reshaping industries across the world. The future of software is no longer a distant dream, it’s happening right now, and we are all part of this exciting transformation. Software 3.0 is changing the way we think about programming.
LLMs are not just tools; they are becoming the core of modern software, enabling anyone to create apps and solutions without needing to write complex code. If you’re not already diving into the world of AI, now is the time to get involved. The possibilities are endless, and the best part is: the future of software is already here.
Let’s embrace this change and start building the future of software together!
Hello, I am Nitika, a tech-savvy Content Creator and Marketer. Creativity and learning new things come naturally to me. I have expertise in creating result-driven content strategies. I am well versed in SEO Management, Keyword Operations, Web Content Writing, Communication, Content Strategy, Editing, and Writing.
