The Big Picture

Something strange happened over the last few years. A piece of software started writing usable code, drafting legal arguments, explaining your blood test, and holding a conversation that — on a good day — is hard to distinguish from a thoughtful colleague. Then it started doing things: editing your files, running commands, booking the meeting, filing the pull request.

If you work in or around technology, you've probably felt two things at once: this is obviously a big deal, and you're not totally sure what's underneath it. This series is about closing that gap. By the end you'll have a clear mental model of the whole stack — from the raw text a model reads, to the engines that serve it at scale, to the agents that act on your behalf.

Let's start with the map.

The one idea you actually need

Almost everything in this series rests on a single, almost insultingly simple idea:

A large language model is a function that, given some text, predicts what text comes next.

That's it. It's a very, very good autocomplete. You give it "The capital of France is" and it predicts "Paris." You give it a half-written function and it predicts the rest. You give it a question and it predicts the answer, because in all the text it learned from, questions tend to be followed by answers.

The surprise of the last few years — the thing nobody fully predicted — is that if you make this autocomplete big enough, and train it on enough of humanity's writing, "predict the next word" turns into something that looks a lot like reasoning, knowledge, and skill. We'll spend post #2 on why that works. For now, just hold onto the core: text in, prediction of next text out.

The stack, layer by layer

Here's the whole landscape we're going to explore, from the inside out — each layer wraps the one before it:

Reading it from the inside out:

• Tokens are the chunks of text the model reads and writes. Not quite words, not quite letters. We cover them in post #3.
• The model itself is a transformer — a particular neural network design that turned out to scale beautifully. Posts #4 and #5 open it up and explain how it's trained.
• Inference is the act of running the model to generate text. It sounds simple but it's full of interesting choices (post #6).
• The inference engine is the heavy machinery that makes inference fast and cheap enough to serve millions of people (posts #7 and #8).
• The harness is the code around the model: the loop that calls it, the system instructions, the parsing of its output, the guardrails. A raw model is a brain in a jar; the harness gives it a body (post #10).
• Tools let the model reach outside its own head — search the web, run code, query a database (post #11).
• Agents are what you get when you put all of this together and let the model pursue a goal over many steps (posts #12–13).

Most public conversation about "AI" smears all of these layers together. One goal of this series is to give you the vocabulary to say precisely which layer you're talking about — because the answer to "why did it do that?" is usually very different depending on the layer.

Why the distinction matters

A quick example. Say an AI coding assistant deletes the wrong file. Where's the bug? It depends entirely on which layer failed:

People who can't separate the layers tend to either over-trust the technology ("it's magic") or over-dismiss it ("it's just autocomplete"). Both are wrong, and both come from looking at the whole funnel as one opaque blob.

A few myths to drop now

Before we go deeper, let's clear out some baggage:

• "It's just looking things up." No. The model has no database of facts it searches. Everything it "knows" is baked into billions of numerical weights during training. That's why it can be confidently wrong — it's reconstructing, not retrieving. (Retrieval is something we add later — that's post #14.)
• "It thinks like a person." It doesn't. The analogies in this series are scaffolding, not claims about consciousness. A model can be brilliant at one task and fail at something a child finds trivial.
• "Bigger is always better." Size helped enormously, but the frontier now is as much about how you train, how you serve, and how you wrap the model as it is about raw parameter count.

What you'll be able to do by the end

This isn't a how-to-build-a-model course — there are excellent ones of those, and most of us will never train a frontier model. This is a how-to-understand-it series, aimed at the much larger group of people who use, build on top of, buy, or make decisions about this technology.

Next up: the heart of the whole thing — what a large language model really is, and why "predict the next token" turned out to be one of the most consequential ideas in computing.