Recommended resources
The freely available resources this lesson will direct you to.
Hello and welcome to your first lesson! We're kicking off your journey into building AI products by tackling the most fundamental question: What exactly is a Large Language Model (LLM), and how does building with one differ from the kind of software development you might be familiar with?
Your goal is to become an indie hacker who can rapidly prototype and ship AI products. To do that, you need a solid mental model for what this new technology is. It’s not just about writing code; it’s about wielding a new kind of computational tool. This lesson will give you that foundational understanding, framing the shift with a powerful concept: the evolution from "Software 1.0" to "Software 3.0".
By the end of this lesson, you'll be able to explain what an LLM is and why programming one with prompts represents a paradigm shift in software creation.
The Three Eras of Software
For decades, "writing software" meant one thing: a human developer giving a computer explicit, step-by-step instructions. This is the world of if/else statements, for loops, and algorithms—what we can call Software 1.0. You've likely written this kind of code yourself. It's deterministic and powerful for well-defined problems, but it breaks down when faced with the ambiguity of the real world. Think about trying to write rules to identify a cat in a photo—the number of rules for fur, ears, and whiskers would be infinite and still fail.
This limitation led to Software 2.0, a term coined by AI researcher Andrej Karpathy. Here, instead of writing explicit instructions, developers train a neural network on massive amounts of data. The network's learned parameters, or "weights," become the program. This was revolutionary for tasks like image recognition and speech-to-text, but it required huge datasets, specialized expertise, and significant computational power, keeping it out of reach for most individual builders.
This brings us to today and the focus of this course: Software 3.0. This new era is powered by Large Language Models.
To understand this shift, let's read a short article that breaks down this framework.
Software 1.0 vs 2.0 vs 3.0: How AI Is Rewriting the Rules of Programming | MindStudio
This article from MindStudio provides a clear and concise overview of the three software paradigms. It's a great mental model to have as we begin.
Please read the first three sections of the article, from the beginning down to the end of the section "Why This Is Different from Software 1.0 and 2.0". Focus on: The definition of Software 1.0 and its core limitation. The key idea behind Software 2.0, where the "program" is the weights. The definition of Software 3.0 and how prompting becomes a form of programming. The critical difference in what skills are needed, which is key for you as an indie hacker.
The key takeaway is that with Software 3.0, you don't need to write every rule or train a model from scratch. You program a vast, pre-existing intelligence using natural language. This dramatically lowers the barrier to entry for building powerful applications.
What Is an LLM, Really?
So, what is this "pre-existing intelligence"? At its core, an LLM is a giant neural network. But what does that mean in practical terms? Let's demystify it.
Andrej Karpathy, who we mentioned earlier, gives a brilliant, practical explanation. He breaks down a powerful open-source model, Llama 2 70B, into its constituent parts. This will help you understand what's happening under the hood when you use an LLM.
[1hr Talk] Intro to Large Language Models
In this clip from his "Intro to Large Language Models" talk, Andrej Karpathy explains that an LLM is, fundamentally, just two files. This is a crucial insight that strips away the mystique.
Watch the section from the beginning of his explanation. Pay close attention to the two components he describes: the parameters file and the run file. This illustrates that the "magic" of the LLM isn't in the code that runs it (which is relatively simple), but in the massive file of learned weights.
As you just saw, an LLM consists of:
- Parameters (Weights): A massive file containing billions of numbers. This is the "brain" of the model. It’s the result of the training process and contains all the learned knowledge and patterns.
- Code (Inference Engine): A comparatively tiny program that uses the parameters to generate text.
The immense cost and complexity lie in creating that parameter file. Running it—a process called inference—is computationally much cheaper.
How Does an LLM Get So Smart?
The process of creating those powerful parameters happens in two main stages: Pre-training and Fine-tuning.
1. Pre-training: Building Knowledge
The first stage is about creating a "base model." This is where the model acquires its vast general knowledge. In essence, the model is trained on a huge portion of the public internet—think Wikipedia, books, articles, and code.
Its objective is simple but powerful: predict the next word.
Given the phrase "The cat sat on the...", the model learns to predict "mat" with high probability. To get good at this task across trillions of words, the model is forced to learn grammar, facts, reasoning abilities, and an incredible amount about how the world works. All this understanding gets "compressed" into its parameters.
[1hr Talk] Intro to Large Language Models
Let's return to Karpathy's talk, where he explains this pre-training process and why the "next-word prediction" task is so effective.
Watch the segment from this section. Focus on his explanation of training as a form of "lossy compression" of the internet and how the simple goal of next-word prediction forces the model to learn about the world.
2. Fine-tuning: Teaching It to Be an Assistant
A base model trained on the internet is a powerful document completer, not a helpful chatbot. If you ask it a question, its instinct is to continue the pattern it has seen online—which might be to provide a list of similar questions, not an answer.
The second stage, fine-tuning, teaches the model to be a helpful "assistant." Model creators use a smaller, high-quality dataset of prompt-and-response pairs, often created by human labelers. This aligns the model's behavior with what users want. It learns the format of a conversation and how to follow instructions, refuse harmful requests, and generally act like a helpful AI.
[1hr Talk] Intro to Large Language Models
Karpathy also clearly explains this crucial second step, distinguishing between the knowledge gained in pre-training and the alignment achieved in fine-tuning.
Watch from this section on fine-tuning. Pay attention to the distinction between the base model (knowledge) and the assistant model (alignment/behavior). This is a critical concept for product builders, as you'll almost always work with fine-tuned assistant models.
The New Development Workflow
Now we can see why building with LLMs feels so different. Let's contrast the development process for a simple task: identifying a cat.
Introduction to large language models
This short video from Google Cloud Tech provides a simple but effective contrast between the old and new ways of solving problems with software.
Watch the clip from this section. It perfectly illustrates the jump from hard-coded rules (Software 1.0) to generative models (Software 3.0) and highlights the key difference in the developer's role.
As the video shows:
- Software 1.0 (Traditional): You'd write explicit rules:
if (legs == 4 && has_fur && likes_yarn) { return "cat"; }. This is brittle and fails easily. - Software 2.0 (Custom ML): You'd gather thousands of labeled cat and non-cat images and train a custom image classification model. This is effective but requires data, expertise, and time.
- Software 3.0 (LLM): You simply ask the pre-trained, fine-tuned model, "What is a cat?" or "Describe this image." The hard work has already been done. Your job shifts from training a model to crafting the right question (prompt design).
This brings us back to the core idea of this course. For an indie hacker, the Software 3.0 paradigm is a massive lever. You can now access world-class AI capabilities through an API and a well-crafted prompt, allowing you to build sophisticated products that would have required a team of PhDs just a few years ago.
Conclusion
In this lesson, we've established a foundational mental model for understanding LLMs and their place in the software landscape.
Key Takeaways:
- LLMs represent a new paradigm, Software 3.0, where we program computers with natural language prompts rather than just explicit code.
- An LLM is fundamentally a large neural network whose "program" is a massive set of parameters, or weights, created through an expensive training process.
- This training happens in two stages: pre-training on internet-scale data to acquire knowledge, and fine-tuning on high-quality examples to align the model's behavior to be helpful.
- This shifts the developer's primary task from writing intricate, deterministic logic (Software 1.0) or training custom models (Software 2.0) to designing effective prompts that guide the LLM's powerful, pre-existing capabilities.
Now that we have a grasp of what LLMs are, the next logical step is to understand what they can and, crucially, cannot do. In our next lesson, we will dive into the specific capabilities and inherent limitations of LLMs, such as hallucination, context windows, and knowledge cutoffs. Understanding these is essential for building robust and reliable AI products.