Recommended resources
The freely available resources this lesson will direct you to.
Welcome to the next step in your journey to building AI products. In our last lesson, we focused on the crucial decision of which LLM to use, comparing the major providers on cost, speed, context, and quality. Now that you have a framework for selecting your engine, we'll explore the fundamental blueprints for what you can build with it.
Today, we will classify the most common LLM product patterns: chatbots, copilots, Retrieval-Augmented Generation (RAG) apps, content generators, workflow automation, and autonomous agents. Think of these as the architectural archetypes of the modern AI product landscape. For you as an indie hacker, understanding these patterns is like a traditional software developer understanding the difference between a mobile app, a web app, and a backend API. It's the foundational vocabulary for mapping your ideas to a concrete implementation.
By the end of this lesson, you'll be able to look at an AI product and deconstruct it into its core pattern, a skill that's essential for both building your own products and analyzing the competition.
A Tour of LLM Product Archetypes
The best way to get a feel for the landscape is a quick tour. We'll explore five broad categories of LLM applications, which cover the six patterns listed in our learning outcome. These patterns aren't always mutually exclusive; many sophisticated products are hybrids. However, understanding them in isolation is the first step.
This video by Sam Witteveen provides an excellent, product-focused overview of the main application types. As you watch, pay attention to the pros and cons he mentions for startups and indie builders.
Please watch the entire video. We will break down each category he presents: Conversational Agents / Chatbots: This section covers the most familiar pattern. Copilots and Duets: This part explains how LLMs act as assistants within other software. Chat with Data / RAG: This segment details the pattern for making LLMs knowledgeable about specific data. Traditional NLP Tasks: This section covers using LLMs as powerful engines for tasks like classification and data extraction, which forms the basis for content generation and workflow automation. Autonomous Agents: The final part introduces the most advanced pattern, where the LLM can reason and act on its own.
Let's dissect these patterns from your perspective as a product builder.
- Chatbots: This is the quintessential LLM app. As the video notes, modern LLMs have made open-domain conversation possible. For a product builder, the key considerations are defining the bot's personality, its scope (what will it talk about?), and its memory (how does it recall past interactions?).
- Copilots: These are assistants embedded in an application. Think of GitHub Copilot for code or the Notion AI assistant for writing. The video makes a crucial point for an indie hacker: building a copilot for a complex, existing software suite (like Microsoft Office) favors incumbents with massive datasets. However, building a copilot for curation and guidance, especially in education or specialized knowledge domains, is a wide-open field for startups.
- RAG (Retrieval-Augmented Generation) Apps: This pattern solves the LLM's knowledge cutoff and hallucination problems by connecting it to a private data source. "Chat with your PDF" is the classic example. The video rightly warns about the "thin wrapper" problem—if your app is just a simple RAG interface, it has no defensibility. A durable RAG product requires building a highly customized and high-quality retrieval system, which is where the real engineering and product value lies. We'll dedicate a whole module to this later.
- Content Generators & "Traditional NLP": As the video explains, LLMs are now state-of-the-art for tasks that used to require specialized models: sentiment analysis, summarization, classification, and data extraction. A content generator is a direct application of this (e.g., a marketing copy generator). More subtly, these capabilities are the building blocks for workflow automation, where an LLM might be one step in a larger, automated process.
This brings us to a critical distinction that often causes confusion: the difference between a workflow and an agent.
The Spectrum of Autonomy: Workflows vs. Agents
Most "automation" you see is a workflow: a series of pre-defined steps. An LLM might power one or more of those steps, but the path itself is fixed. An agent, by contrast, is given a goal and decides the path for itself. It can reason, plan, and use tools to achieve its objective.
Understanding this difference is fundamental to AI product architecture. Let's get a clearer picture of this progression from simple instruction-following to autonomous action.
This video by Jeff Su provides a brilliant, layered explanation that builds from a basic LLM call to a workflow, and finally to an agent. It makes the abstract concepts of reasoning and acting very concrete.
Watch the following segments to see the step-by-step evolution: Level 1: Large Language Models: This part recaps the basic input/output nature of LLMs and their passivity. Level 2: AI Workflows: This section is key. Notice how the human defines a fixed path for the LLM to follow, including using external tools like a calendar. He correctly classifies RAG as a type of workflow. Level 3: AI Agents: Here is the crucial leap. The key insight is that an agent replaces the human decision-maker with an LLM. The LLM itself reasons about the plan and acts by selecting tools. Summary: This final summary provides a concise visual recap of the three levels.
As the video makes clear, the defining characteristic of an agent is that the LLM is the decision-maker in the workflow. It's not just executing a step; it's creating the steps. This is often described by the ReAct (Reason → Act → Observe) framework, which we will implement in a later module.
To solidify this distinction, let's look at a textual breakdown.
Understanding AI Agents, Workflows, and Automation | Rakesh Gohel posted on the topic | LinkedIn
This LinkedIn post offers a structured, side-by-side comparison of traditional automation, AI workflows, and AI agents. It's a great cheat sheet to have.
Read the main body of the post, starting from the beginning down to the examples. Focus on the definitions provided for AI Workflow and AI Agents. Note the differences in their "Working," "Learning," and "Built-in Logic" characteristics.
The post highlights that AI Workflows are "logically derived but still lack the concept of Self-learning" and depend on "pre-defined logic flow." In contrast, AI Agents are "fully Autonomous with reasoning" and capable of "self-learning."
The Anatomy of an Agent
An agent isn't just a smarter LLM; it's an architecture. A capable agent combines an LLM "brain" with a set of tools and a process for using them.
This image beautifully illustrates the agentic principle. The agent has a goal (answer the query) and a toolbox. Its job is to create and execute a plan using those tools. This is a far more powerful and flexible pattern than a simple RAG workflow that is hardcoded to always search a single vector database.
Conclusion
In this lesson, we've surveyed the primary architectural patterns for LLM-powered products. You can now classify applications based on how they use the underlying model's capabilities.
Key Takeaways:
- LLM products fall into several common patterns: Chatbots, Copilots, RAG Apps, Content Generators, Workflows, and Agents.
- These patterns exist on a spectrum of complexity and autonomy.
- Workflows involve an LLM executing steps within a fixed, human-defined process.
- Agents are autonomous systems where the LLM itself reasons, plans, and selects tools to achieve a goal. The LLM is the decision-maker.
- As a product builder, your choice of pattern has major implications for complexity, cost, and defensibility. A simple RAG app might be easy to build but hard to defend, while a true agent is complex but can create unique value.
You now have the vocabulary to deconstruct AI products and conceptualize your own. In our next lesson, we'll address a critical product decision: for any given problem, should you use an LLM at all? We'll develop a framework for deciding when an LLM-based pattern is the right tool for the job versus when deterministic code or a simple API is the better, faster, and cheaper solution.