LLM Foundations (GA-101)
A support bot confidently invents a refund policy that does not exist. A summarizer that worked all week suddenly drops the last third of every long document. A prompt that costs a fraction of a cent at your desk quietly costs thousands at scale. Behind each of these is not magic and not a bug report — it is a large language model doing exactly what its design makes it do. This course teaches you to see that design clearly enough to predict the behavior before it surprises you in production.
GA-101 is the entry point to the School of Generative AI. It is the mental-model course: almost no API calls, no cost, and no cloud account. Instead it gives you the vocabulary and judgment every later course lands on — what a large language model (LLM) actually is, why tokenization explains half the strange behavior you will ever see, and where these systems are reliable versus where they quietly fail. When you finish, you can reason about model behavior, read a model card critically, and decide when an LLM is the wrong tool.
- Explain how an LLM produces text through next-token prediction, and distinguish training from inference - Describe what a "model" is: learned weights that map context to a probability distribution over tokens - Break text into tokens and explain why token count, not word or character count, drives context limits and cost - Reason about the context window as a fixed budget, and predict what happens when a conversation exceeds it - Identify hallucination and other failure modes, and decide when grounding or a non-LLM approach is the responsible choice
Who this course is for
This is the front door of the school. It is written for four kinds of learner:
- The application developer with strong Python and API skills and no machine learning background, aiming to ship LLM-powered features.
- The AI engineering graduate who has the classical machine learning grounding and wants the generative layer on top; module quizzes let you move quickly through overlap.
- The data engineer adding generative AI who will soon own the retrieval corpus that feeds an LLM and needs to reason about tokens and context.
- The technical lead deciding what their team should build, who needs sound intuition before approving an architecture.
Prerequisites
Comfort reading a short Python snippet and running it locally. You do not need a machine learning background, a paid model API, a GPU, or a cloud account. Every hands-on exercise in this first slice of the course either deep-links into the Prompt Playground or runs in a few lines of standard-library Python on your own machine, so it stays free and offline.
Modules
GA-101 is roughly fourteen hours of effort across eight modules. This first slice delivers the three foundational lessons and your first hands-on lab.
| # | Module | What you leave with |
|---|---|---|
| 1 | What an LLM is | Next-token prediction as the one core mechanism |
| 2 | Tokenization | Why tokens explain cost, limits, and odd behavior |
| 3 | The transformer, by intuition | Embeddings, attention, and layers without the math |
| 4 | Training pipeline | Pretraining, instruction tuning, preference alignment |
| 5 | Sampling and decoding | Temperature, top-p, and why outputs vary |
| 6 | Context windows and memory | What the model does and does not "know" |
| 7 | Capabilities and failure modes | Hallucination, sycophancy, and jagged skills |
| 8 | Reading the landscape | Model cards, benchmarks, and open vs. hosted models |
The three lessons and the lab below cover the core of Modules 1, 2, 6, and 7 and give you the token-and-context reasoning the rest of the school builds on.
Outcomes
By the end of GA-101 you can:
- Explain, without hand-waving, how an LLM turns a prompt into text one token at a time.
- Estimate the token cost of a prompt and predict when a conversation will overflow a model's context window.
- Diagnose a class of "weird" model behaviors as token-boundary artifacts rather than reasoning failures.
- Recognize hallucination and decide when to ground a model, constrain it, or refuse to use one at all.
Where this leads
GA-101 pairs with GA-102: Prompt Engineering — both are Foundation courses you can take in parallel, and both gate GA-201: Building with LLM APIs, the hub course every practitioner track flows through. The token and context intuition you build here is exactly what GA-201 uses to meter cost and truncate conversations, and what GA-202: RAG Systems uses to decide how much retrieved text fits in a prompt. Start here, and those courses land on prepared ground.
Do the lessons in order. Each introduces vocabulary the next assumes, and the lab at the end turns the token and context-window ideas into a small tool you run yourself — no API key, no cost.