2.1 LLMs in Plain Language

Every AI assistant you've ever used — Claude, ChatGPT, Gemini — runs on the same kind of engine: a large language model. This lesson explains what that engine does, using zero math, and shows why "it just predicts the next word" is both completely true and wildly misleading.

What you will learn

• Explain what an LLM does in one sentence a friend would understand.
• Describe how training works at the concept level: pretraining, then refinement.
• Resolve the paradox: how can a "next-word predictor" write working software?

Builder principle

Understand the machine as it is — not as marketing sells it or doomers fear it. Clear sight is a competitive advantage.

The one-sentence version

A large language model is a program trained on a massive amount of text that, given some text, predicts what should come next — and does it so well that the predictions amount to writing, reasoning, and code.

That's genuinely it. When Claude answers you, it's generating the response one small chunk at a time, each chunk chosen as "what most plausibly comes next" given everything before it.

How it gets that good: training in two acts

Act one: pretraining. The model reads an enormous slice of human text — books, articles, code, conversations. For every fragment, it plays the same game: guess the next chunk, check the answer, adjust. Trillions of rounds. To get good at this game, it's forced to internalize spelling, grammar, facts, logic, code syntax, argument structure — because all of those are patterns that help you guess what comes next.

Think about what it takes to finish this sentence well: "The capital of France is ." Now this one: "The bug is in line 14 because the loop never ." Accurate prediction can require rich internal representations of language, facts, and relationships. Researchers still debate what kinds of "understanding" those representations support, so treat understanding as a useful behavioral question, not a settled peek inside the model.

Act two: refinement. Raw pretrained models are like brilliant, feral libraries — they complete text but don't converse or behave. So they're refined: trained on examples of helpful dialogue, tuned with human feedback about which answers are good, given guidelines about being honest and safe. This turns "text completer" into "assistant."

Watch

Large Language Models explained briefly — 3Blue1Brown makes this visual in 8 minutes. If you skipped it at the chapter intro, now's the moment.

"Just predicting words" — the misleading part

Critics say "it's just autocomplete." Here's why that undersells it:

• Prediction at this scale builds useful representations. Models encode many regularities about plumbing, law, and Python in learned parameters. Those patterns can support impressive answers, but they are not a source database, a guarantee of truth, or proof that the model represents the world as a person does.
• Generation is iterative. The model builds a response chunk by chunk, each choice conditioned on prior context and generated text. Asking for intermediate work can help on some tasks, but it can also produce a persuasive wrong path. A written chain of steps is output to evaluate, not a faithful trace of hidden computation.
• Agents close the loop. A prediction machine wired to tools — file access, command execution, the results fed back in — stops being autocomplete and starts being a worker. Predict an action, take it, see the actual result, predict the next action. That's the agentic loop from Lesson 1.2, and it's grounded in reality, not vibes.

What this means for how you work

Three practical consequences you'll use every day:

1. The model can only use what training encoded plus context and tools available now. It cannot see your files, intent, or standards unless the product gives it access or you place them in context. (Next lesson.)
2. Better input text → better predictions. A clear brief with an example produces better work than a vague wish — not because the model is being difficult, but because you narrowed the prediction target.
3. Confidence and correctness are not the same signal. Fluent text is what it was trained to produce. Fluency is free; truth requires verification. (Lesson 2.4.)

Try it now

Open Claude (the chat app is fine for this) and run a small experiment:

1. Ask: Finish this sentence: "The best time to plant a tree was twenty years ago; the second best time is"
2. Then ask: Give me two plausible explanations of how a language model could produce that completion. Label what is established mechanism, useful analogy, and speculation.
3. Treat both explanations as generated accounts, not introspection: the model does not read out its own hidden activation history for you.
4. Then try: Write the first line of a Python function that checks if a word is a palindrome — and notice that learned patterns support both familiar prose and code, with neither guaranteed correct.

Journal one sentence: what would you need to verify independently before treating a model's explanation of itself as fact?

Check your understanding

• What does an LLM do, in one sentence?
• What are the two acts of training, and what does each contribute?
• What is the difference between useful learned representations and a guaranteed store of facts?
• Why is a model's explanation of its own answer not an introspective process trace?
• What turns a prediction machine into a worker?