You made it. Ten chapters ago, "AI", "LLM", and "agent" were words you'd heard; now they're a story you watched happen. This last chapter is a toolkit for what comes after the book: check what stuck, practice deliberately for a month, keep a glossary within reach, and know which door to open next.

The whole arc in ten sentences

AI is the broad project of making machines do things that seem to require intelligence, and the old way — hand-written rules — broke the moment the world got messy. Machine learning replaced hand-written rules with knobs tuned automatically against examples, which is why data quality is destiny. To learn from language, machines first turn words into tokens and tokens into vectors — coordinates on a giant map of meaning where similar words sit near each other. An LLM is a colossal next-token predictor: it reads everything in its context window, uses attention to decide which earlier words matter for the next one, and picks a likely next token, thousands of times in a row. It's made in stages — pretraining on much of the internet, then fine-tuning on examples of good behavior, then preference training to reward the better answer, and lately reasoning training that rewards checkably right answers reached via private scratch-work (the "thinking" toggle) — which is how a raw text-predictor becomes a helpful assistant with a knowledge cutoff. Talking to it well means managing its short-term memory (the context window), knowing that wording is a steering wheel, and remembering that fluent is not the same as true. RAG and tool calling break the model out of the chat box: it can look things up open-book style and call real software instead of guessing. An agent is that same LLM put in a loop — goal, plan, act with a tool, observe, repeat — until the dinner is actually booked. The agentic world scales this with patterns like orchestrator-and-workers, and with MCP as a common plug for tools; some of it ships today, some is still demo-ware. And the frontier of all this ability is jagged — superhuman here, sub-child there — so the master habit is: predict, then test, then verify what matters.

The staircase shows the story as a journey; here's the same book as a map — every big idea and the arrow that connects it to the next. This is the picture to test yourself against: close the book, grab a napkin, and see how much of it you can redraw. Whatever you can't redraw is the section to reread.

Self-check: ten questions

Answer each one out loud in your own words before opening the answer — explaining to an imaginary friend is the test that matters. If you can get eight, you've kept the promise on the cover.

1. Why does an LLM sometimes confidently state false facts?

Because it's always doing the same thing: predicting plausible next tokens. "Plausible" is judged by patterns in training text, not by checking reality — so a fluent, typical-sounding falsehood (like a fake but perfectly formatted citation) can be more likely than the awkward truth. It isn't lying; it's fluent guessing with no built-in truth meter.

2. What's the difference between a workflow and an agent?

A workflow follows a route a human designed in advance: step 1, step 2, step 3, done — the LLM fills in the steps but doesn't choose them. An agent chooses its own steps: it gets a goal, picks a tool, observes the result, and loops — deciding as it goes. Workflows are predictable and cheap; agents handle open-ended tasks but can wander.

3. Why does starting a new chat sometimes fix things?

Everything in a conversation sits in the model's context window — its short-term memory — and influences every next token. A long chat full of wrong turns, corrections, and confusion keeps steering new answers toward old mistakes. A fresh chat empties the window, so the model starts from a clean slate instead of a polluted one.

4. What actually happens, step by step, when a chatbot writes one word of its reply?

Roughly five steps: (1) your text is split into tokens; (2) each token becomes a vector — a point on a giant meaning-map; (3) attention lets every token look back at the others to see which matter for what comes next; (4) the model scores every possible next token with a probability; (5) one is sampled and appended — then the whole loop runs again for the next token.

5. Why can a model that aces the bar exam lose at tic-tac-toe?

The jagged frontier. LLM ability comes from language patterns in training text, so pattern-rich verbal tasks (essays, translation) fall well inside its reach, while exact symbolic procedures (game rules, big arithmetic, counting letters it can't even see, because it reads tokens) fall outside. Human difficulty and AI difficulty are different maps — so you test, never assume.

6. What are the three main stages of making an LLM assistant?

Pretraining (predict the next token across a huge slice of the internet — this builds raw language ability and knowledge), supervised fine-tuning (show it many examples of helpful question-and-answer behavior), and preference training such as RLHF (humans compare answers; the model is rewarded for the preferred one). Base model in, assistant out.

7. What is RAG, and what problem does it solve?

Retrieval-augmented generation: before the model answers, relevant documents are fetched and pasted into its context window, so it answers open-book instead of from memory. It fights hallucination and the knowledge cutoff at once — the model quotes what's in front of it rather than reconstructing what it vaguely absorbed during training.

8. Why is prompt injection so hard to fix?

Because to the model, your instructions and the webpage it's reading arrive the same way — as tokens in one context window. Telling command from content is a learned tendency, not an enforced rule, so a malicious sentence hidden in fetched content can masquerade as an instruction. Mitigations (least privilege, human confirmation) reduce the damage but don't eliminate the confusion.

9. Does the chatbot learn from your conversations while you chat?

No. The model's knobs — its parameters — are frozen after training. Within one conversation it "remembers" only because the transcript sits in its context window; close the chat and that's gone. On consumer plans, logged conversations typically are used to train future model versions unless you opt out (a setting worth two minutes; business and API tiers are usually excluded) — but the model you're talking to is not updating itself as you type.

10. What is temperature, and when would you turn it up or down?

A dial on the sampling step: low temperature makes the model pick its top-probability tokens almost every time (consistent, safe, sometimes dull — good for factual extraction or code); higher temperature lets it gamble on less likely tokens (varied, creative, sometimes unhinged — good for brainstorming names or story ideas).

Myth vs. reality: the misconception boxes, reunited

Scattered through the book were small boxes correcting the things everyone gets wrong. Here they all are in one table — the version to keep handy for dinner-party corrections. Each row links back to the chapter that makes the full argument.

The myth	The reality	Chapter to revisit
"It's Google — it looks up answers in a database."	There is no database of answers. The model generates every reply token by token from patterns baked into its knobs during training. That's why it can answer questions nobody has ever asked — and why it can invent things nobody ever said.	Ch 4: What Is an LLM?
"It just copies chunks of its training text."	The training data isn't stored inside the model — trillions of tokens were compressed into patterns, not filed away as documents. Outputs are newly generated; occasional near-verbatim recall of famous passages is the exception that gets the headlines, not the mechanism.	Ch 4: What Is an LLM?
"It's learning from my conversations right now."	The knobs are frozen at inference time. Within a chat it "remembers" only what's in the context window; close the tab and it's gone. Consumer tiers do typically use logged chats to train future models unless you opt out (business tiers typically don't — check the setting) — but the model you're talking to isn't updating itself as you type.	Ch 5: How an LLM Is Made
"Agents are a new kind of AI model."	An agent is the same LLM you've been chatting with, placed in a loop with tools and feedback by ordinary software. The magic is in the scaffolding, not a new brain — which is why agent quality tracks model quality so closely.	Ch 8: What Is an AI Agent?
"Multi-agent = smarter."	More agents means more cost, more latency, and more places to fail — sometimes for better results, often not. Orchestrator patterns earn their keep on genuinely parallel work; for everything else, one good model with one good prompt wins. Start simple.	Ch 9: The Agentic World
"AGI is basically here" — and its twin, "it's all hype, just autocomplete."	Both extrapolate from half the picture. The frontier is jagged: superhuman at bar-exam essays, sub-child at counting letters. Genuinely powerful and genuinely unreliable at once — which is duller than either headline, and true.	Ch 10: Limits, Risks & the Jagged Frontier

The next 30 days

Week	Theme	What you do, daily	What you're learning
1	Make it a habit	Bring one real task a day to a chatbot — an email to soften, a plan to poke holes in, a concept to explain, a menu for Mom. No technique yet; just use it on things you actually care about.	Your personal map of the jagged frontier: where it delights you, where it flops, on your work.
2	Prompt deliberately	Take each day's task and run it twice: once lazily, once with chapter 6's patterns — give context and role, show an example, ask for step-by-step reasoning, iterate on the draft. Compare the two outputs.	That wording is a steering wheel: the gap between a lazy prompt and a deliberate one is often the whole product.
3	Documents & tools	Work RAG-style: upload or paste real documents (a contract, a report, meeting notes) and interrogate them. Try tool-flavored features — web search, data analysis, image input. Verify one claim per day against the source.	Why supplied-document tasks beat open recall, and what tool calling feels like from the user's chair.
4	Watch an agent work	Run a real agent and observe its loop: a deep-research feature on a question you genuinely have, or a coding agent if you're adventurous. Watch it plan, act, observe, adjust. Note where it loops well and where it wanders. Approve — don't rubber-stamp — its actions.	The four-step agent loop in the wild, plus healthy habits: least privilege, human confirmation, checking the work.

If tables aren't how you think, here's the same month drawn as a skill tree — the video-game view, where each week's practice unlocks the next branch:

At the end of the month, do one thing: explain AI → ML → LLM → agent to a real person over coffee, using the dinner story or your own. Teaching it is how you find the gaps — and there's no better proof the book worked.

Glossary: 40 terms in plain language

Agent

An LLM put in a loop with tools and feedback: it gets a goal, picks actions, observes results, and repeats until done. The key word is loop — it decides its own next step.

AI (artificial intelligence)

The broad project of making machines do things that seem to require intelligence — from chess programs to chatbots. An umbrella term, not one specific technology.

Alignment

The effort to make a model's behavior match human intentions and values — helpful, honest, harmless — mostly via fine-tuning and preference training after pretraining.

Attention

The mechanism that lets each token look back at every other token in the context and weigh which ones matter for predicting what comes next. It's how "bank" learns whether it's near a river.

Base model

The raw result of pretraining: a pure next-token predictor that continues text but doesn't yet behave like an assistant. The dough before the baking.

Benchmark

A fixed test set (exam questions, coding puzzles) used to score models against each other. Useful for comparison; a poor predictor of messy real-world performance.

Bias

Systematic skew in a model's outputs, inherited from patterns in its training data — like associating professions with genders. Reduced by alignment training, never fully eliminated.

Chain of thought

Getting a model to write out intermediate reasoning steps before its final answer. Because each step becomes context for the next, this often improves accuracy on multi-step problems.

Context window

The model's short-term memory: the maximum amount of text (in tokens) it can consider at once. Everything it "knows" about your conversation lives here — nothing more.

Deepfake

AI-generated or AI-altered media — a face, a video, a cloned voice — convincing enough to pass as real. Detection tools are unreliable; watermarks (like SynthID) only mark cooperating generators' output, so verify the source, not the pixels.

Embedding / vector

A word or document converted into a list of numbers — coordinates on a giant meaning-map where similar things sit near each other. The reason king − man + woman lands near queen.

Fine-tuning

Additional training on a smaller, curated dataset to teach a pretrained model a specific behavior or style — for example, answering questions helpfully instead of just continuing text.

Foundation model

A very large model trained on broad data that many different applications are then built on — the shared foundation under chatbots, coding tools, and agents alike.

GPU

The chip (graphics processing unit) that does thousands of simple calculations in parallel — originally for video-game graphics, now the workhorse that makes training and running LLMs feasible.

Hallucination

When a model confidently states something false — a made-up fact, quote, or citation. A side effect of predicting plausible text rather than checking truth.

Inference

Using a trained model to produce answers, as opposed to training it. Every chatbot reply you've ever received was inference: knobs frozen, tokens flowing.

Jagged frontier

Ethan Mollick's name for the weird boundary of AI ability: superhuman at some tasks, surprisingly bad at seemingly easier neighbors. You can't predict which side a task is on — you test.

Knowledge cutoff

The date the model's training data ends. Events after it simply aren't in the model's memory — a big reason tools like web search and RAG exist.

LLM (large language model)

A neural network with billions of knobs, trained on enormous amounts of text to predict the next token — and, through that one skill, able to write, translate, summarize, and converse.

MCP (Model Context Protocol)

An open standard for connecting AI applications to tools and data sources — "USB-C for AI tools": build a connector once, and any compatible AI app can plug into it.

ML (machine learning)

Making computers learn behavior from examples instead of following hand-written rules — tuning millions of knobs until the outputs match the examples. The engine inside modern AI.

Multimodal

Able to work with more than text — images, audio, sometimes video — as input, output, or both. Modern frontier models can look at your photo and discuss it.

Neural network

A learning system built from layers of simple number-crunching units whose connection strengths (the knobs) are tuned during training. Loosely inspired by the brain; mostly just very organized arithmetic.

Open weights

A model whose trained parameters are published for anyone to download and run on their own hardware — as opposed to models reachable only through a company's servers.

Orchestrator

In multi-agent systems, the lead agent that breaks a big task into pieces, hands them to worker agents, and assembles their results — a project manager made of tokens.

Parameter / knob

One of the tunable numbers inside a neural network — this book calls them knobs. Modern LLMs have billions to trillions of them; training is the process of setting them.

Pretraining

The first and biggest training stage: predicting the next token across a vast slice of the internet, over and over, until language ability and world knowledge emerge in the knobs.

Prompt

Whatever you feed the model — question, instructions, examples, documents. The steering wheel: small wording changes can produce very different outputs.

Prompt injection

An attack that hides instructions inside content an AI will read (a webpage, an email) so the model treats attacker text as commands. The central unsolved security problem for agents.

RAG (retrieval-augmented generation)

Fetching relevant documents and putting them in the model's context before it answers — an open-book exam instead of a closed-book one. Cuts hallucination and beats the knowledge cutoff.

Reasoning model

A model trained — by rewarding checkably correct answers to math and code problems — to "think" at length before answering: drafting private scratch-work tokens, checking itself, then writing the visible reply. The "thinking" toggle in 2026 chat apps; slower and costlier, but much stronger on math, logic, and planning. The extra answer-time effort is called test-time compute.

RLHF (reinforcement learning from human feedback)

A preference-training technique: humans compare pairs of model answers, and the model is nudged toward producing the kind people preferred. A big part of why assistants feel helpful and polite.

Sampling

The step where the model actually picks the next token from its probability scores. Because it picks probabilistically rather than always taking the single top choice, the same prompt can give different answers.

System prompt

Hidden standing instructions the provider or developer places before your conversation — the model's job description ("You are a helpful assistant; refuse X; format Y"). You rarely see it, but it shapes every reply.

Temperature

A dial on sampling: low = nearly always pick the top token (consistent, predictable), high = gamble on less likely tokens (varied, creative, riskier). Same model, different personality.

Token

The chunk of text a model actually reads and writes — often a word, sometimes a piece of one ("straw" + "berry"). Models see tokens, not letters, which explains some famous failures.

Tool calling

Letting the model request that real software be run — a web search, a calculator, a calendar booking — and get the result back as text to work with. The bridge from talking to doing.

Training data

The examples a model learns from: for LLMs, trillions of tokens of web pages, books, code, and more. Its patterns — knowledge, style, and biases alike — become the model's patterns.

Transformer

The neural-network architecture behind modern LLMs (the T in GPT), built as a stack of layers that repeatedly apply attention — re-reading the text with sharper understanding at every layer.

Workflow

An LLM-powered pipeline whose steps a human wired in advance: do A, then B, then C. Predictable and efficient; contrast with an agent, which chooses its own steps as it goes.

Where to go next: a graded reading list

Ordered from easiest to deepest. Don't read them all — pick the next rung on your ladder.

1. Ethan Mollick — Co-Intelligence (book) and One Useful Thing (newsletter). The best next step for almost every reader of this book: how to actually work with AI, evidence over anecdote, zero code. Start here, starting today.
2. Timothy B. Lee & Sean Trott — "Large language models, explained with a minimum of math and jargon" (Understanding AI). One long article that retells chapters 3–5 of this book with more precision and wonderful diagrams. Ready when you finish this page.
3. Jay Alammar — "The Illustrated Transformer" (jalammar.github.io). The classic visual walkthrough of the transformer's internals, one picture per idea. Ready when you want to see what's inside the attention box we treated as a matchmaking service.
4. 3Blue1Brown — neural networks video series (YouTube). Gorgeous animated math showing what "tuning knobs" really means, gradient descent and all. Ready when light math (graphs, slopes) sounds fun rather than frightening.
5. Transformer Explainer (poloclub.github.io/transformer-explainer). A live, interactive transformer running in your browser — type text and watch attention and probabilities flow. Ready any time; best after Alammar, when the labels mean something.
6. Andrej Karpathy — "Intro to Large Language Models" (1-hour talk), then "Let's build GPT" (code-along). The talk is a superb no-code overview from a top researcher; the code-along, where you build a tiny GPT yourself, is the deep end. Ready for the talk now; ready for the build when you know some Python.
7. Anthropic — "Building Effective Agents" (anthropic.com). The short engineering essay behind chapters 8–9: workflows vs. agents, the patterns, and the advice to start simple. Ready when you want to build — or judge builders' claims.
8. Simon Willison — simonwillison.net. The field's sharpest running notebook: new models tested within hours, prompt-injection coverage, honest hype-checks. Ready when you want a trustworthy daily signal amid the noise — deep, but you can skim forever.

A short goodbye

Here's the thing about the field you've just learned: it will not sit still. The models in the news this month will look quaint by next year; the jagged frontier will lurch outward in places nobody predicted; some of chapter 9's "shipping today" will be obsolete and some of its "hype" will be real. That's fine — because none of it invalidates what you now carry. Tokens and vectors, the prediction loop, training versus inference, the context window, tools and the agent loop, the jagged frontier and the verification habit: these are the stable load-bearing ideas, and every shiny new thing will be built out of them. You can now read the news and sort substance from noise, use these tools and know why they fail the way they fail, and — most importantly — explain all of it to someone else over dinner. Perhaps a birthday dinner. Somebody has to pick the restaurant, and now you know exactly how much help you can trust.

One last way to see what you've gained: learning AI is like learning to drive. You never needed to build an engine — and this book didn't teach you to build one — but you now know what the engine can and can't do, and that knowledge is what keeps you out of ditches: you don't floor it on ice (don't trust recalled facts on high-stakes questions), you check the mirrors before changing lanes (verify before you ship), and you know the strange sound that means "pull over" (the too-confident answer to the question it couldn't possibly know). The analogy breaks in one honest place — a car behaves the same way every morning, while this engine gets rebuilt under you every few months. Which is exactly why you learned the principles instead of the dashboard: dashboards change; the physics of the road doesn't.

That's the end of the book's main story — but not of the book. Part V — Living with AI is a set of six field guides for the world these systems are building around you: the "thinking" toggle in your chat app, voices that can be cloned, images that can't be trusted on sight, chatbots that feel like friends, agents that reach for your wallet, and what all of it means for your job and your kids' homework. Read them in order or dip in as life raises each question.