What a large language model actually is

You have probably typed something into ChatGPT, gotten back a paragraph that sounded like a person wrote it, and wondered what was actually happening on the other end. This lesson answers that. No math, no jargon we don't explain. By the end you'll have a mental model that holds up — one you can build the rest of the course on.

Here it is in one line, and everything else is just unpacking it:

A large language model is a system that predicts the next chunk of text, over and over.

That's the whole trick. Let's make it real.

Autocomplete that read almost everything

You already know a small version of this. Your phone suggests the next word as you text. Type "running late, be there in a" and it offers "minute" or "bit." It isn't reading your mind. It has seen enough messages to know what usually comes next.

A large language model (LLM for short) is that same idea, scaled up almost past belief. Instead of learning from text messages, it learned from an enormous slice of the written world — books, articles, websites, code, conversations. And instead of suggesting one next word, it keeps going: predict a chunk, add it to the text, then predict the next chunk based on everything so far, again and again, until it has written a whole answer.

So when you ask a question, the model isn't "answering" the way a person would. It's continuing the text. Your question is the beginning; its reply is the most likely continuation, built one small piece at a time.

The analogy has a limit, and it matters. Your phone's autocomplete is dumb and local, working off a tiny list. An LLM has absorbed so many patterns — grammar, facts, tone, the steps of an argument, the shape of a good explanation — that its next-chunk guesses can look like genuine thought. Same mechanism, wildly different scale. Hold onto both halves of that.

Trained, not programmed

Here's the part that trips up almost everyone new to this.

Normal software is programmed. A human writes explicit rules: if the user clicks this, do that. Every behavior traces back to a line someone typed on purpose.

An LLM is trained, which is completely different. Nobody wrote a rule for how to answer your question. Instead, the model was shown mountains of text and made to play one game, over and over: here's some text with the next piece hidden — guess it. Each time it guessed wrong, its internal settings got nudged a little so it would guess better next time. Do that an enormous number of times, and the model gradually soaks up the patterns of language on its own.

Take one idea from this section: no human wrote the model's rules — it learned them from examples. That's why even the people who build these systems can't point to the line of code that makes one answer polite and another wrong. There is no such line. There are only patterns, learned.

What "large language model" means, word by word

Language model is the honest, boring name for what it does: it models how language tends to continue. Give it some text, and it estimates what's likely to come next. That's the model — a giant, learned sense of "what usually follows what."

Large refers to the number of parameters — the internal dials the model adjusts during training. Picture a mixing board with billions of tiny knobs. Each knob nudges how one pattern feeds into the next-chunk guess. Training is the slow work of turning every knob to a good setting. "Large" language models have billions of these dials, which is what lets them capture patterns subtle enough to feel intelligent.

You don't need the exact count. You need the picture: billions of learned dials, all working together to guess the next chunk of text.

Two things it is not — clear these out now

Because the output looks so human, two wrong pictures form instantly. Get rid of both before we go further.

It does not look things up. An LLM is not a search engine, and not a filing cabinet of facts it opens to fetch an answer. When it tells you something, it's predicting text that sounds like a correct answer, based on patterns from training. Usually that lands on the truth, because true statements were common in what it read. But sometimes it produces something fluent and flatly wrong, with total confidence. That failure has a name — hallucination — and it isn't a glitch bolted on. It's the same next-chunk prediction that powers everything else, aimed at a spot where the pattern was thin. One thing follows from this that surprises people: the model's knowledge is frozen at the moment its training ended. It hasn't read today's news, it can't check anything live, and it doesn't remember what you told it in yesterday's separate chat. Every conversation starts cold.

It does not understand the way you do. When you read "the coffee was too hot to drink," you get it because you've burned your mouth. The model has no mouth, no coffee, no experiences. It has statistics about how those words travel together. The results can be so good it's tempting to say it "knows" things — but underneath there's no inner life, no beliefs, no awareness. Just extraordinarily well-tuned prediction. Keeping this straight saves you from both over-trusting it and being spooked by it.

Why this one trick is the whole course

You might reasonably ask: if it's just predicting the next chunk, how does it write code, translate languages, or summarize a report?

That's exactly the question the rest of the course answers. It turns out that to predict text well enough — across everything humans write — the model has to pick up a startling amount along the way: grammar, facts, styles, even rough reasoning. Capability is a side effect of getting really, really good at one simple game.

From here we open the box. Next you'll see how your words get chopped into the "chunks" the model actually works with. Then how it runs the moment you hit send, and how all that training happened in the first place.

One trick, taken to an extreme. That's a large language model. Now let's see how the extreme is built.