Back

LLMs Explained Like I'm Five

July 10, 2026 (1w ago)

A simple tour of large language models: next-word guessing, tokens, training vs chatting, and why they sound smart even when they are wrong.

LLMs guess the next word like fancy autocomplete

Imagine your phone’s autocomplete… but it has read a ridiculous amount of the internet, books, code, and conversations. That is the simplest honest picture of a large language model (LLM).

It is not a tiny human living in a server. It is not a search engine with feelings. It is a machine that is unusually good at answering one question, over and over:

Given the text so far, what is likely to come next?

Do that thousands of times in a row, and you get a paragraph, a poem, a bugfix, or a recipe for banana bread.

This post keeps the metaphors small on purpose. No math homework. Just the mental model.

Note: “Like I’m five” here means clear, not babyish. You can be five and still deserve the truth.

The magic trick is next-word guessing

Say you write:

Once upon a

A trained model might think something like:

time   -> very likely
day    -> somewhat likely
night  -> less likely
pizza  -> almost never (in this context)

It picks something (often the likely ones, sometimes a spicier option), appends it, and guesses again:

Once upon a time
Once upon a time there
Once upon a time there was
...

That loop is the whole show. Chatbots feel smart because language itself is packed with patterns — grammar, facts people often write, coding styles, polite answers — and the model has practiced those patterns at enormous scale.

Tokens are LEGO bricks of text

The model does not usually think in full English words the way you do. It chops text into tokens: little chunks that might be a word, part of a word, a space, or punctuation.

Sentence split into tokens

Why bother?

When people say a model has a “context window,” they mean: how many tokens it can look at at once while guessing. Too long a conversation and older bits may fall off the table.

Training vs chatting

There are two very different moments in an LLM’s life.

Training versus chatting

Training (learning time)

Engineers feed the model mountains of text and make it practice: hide a word, guess it, nudge the internal knobs when it is wrong. After enough practice, the knobs encode useful statistical patterns about language.

This step is slow and expensive. You do not retrain the whole universe every time you ask a question.

Inference (chat time)

You type a prompt. The model uses those frozen knobs to predict the next token, then the next, then the next. That is the part that feels like chatting.

A helpful analogy:

Why it can write code (and still mess up)

Code is also just text with strong patterns:

function add(a, b) {
  return a + b;
}

If a model has seen millions of similar snippets, “what usually comes after function add(a, b) {” is often guessable. That is why LLMs can look like junior developers.

But guessing is not verifying. The model does not run your program unless some other tool does. So it can invent a function that looks right, cite a library that does not exist, or confidently skip a bug.

A five-year-old version of the warning:

It is great at sounding right. Sounding right and being right are different games.

Hallucinations, in kid words

Sometimes the model blurts out something that fits the shape of a good answer but is false — a fake quote, a made-up paper, a wrong date.

That happens because its job was never “look up the one true fact.” Its job was “continue the text in a plausible way.” Plausible can still be wrong.

Practical habit: for important facts (medicine, law, money, “did this API exist?”), check another source.

Temperature: spicy vs safe guesses

When the model has a list of possible next tokens, we can choose:

Want a legal email? Turn the spice down. Want a silly bedtime story about a robot raccoon? Turn it up a little.

Prompts are the steering wheel

Because the model continues whatever you give it, your prompt is part of the story it is finishing.

Compare:

Write a scary story.

vs

Write a 4-sentence scary story for a 5-year-old.
Use friendly words. End with a cozy hug. No gore.

Same model, different rails. Clear instructions, examples, and constraints help a lot — not because the model “obeys rules” like a person, but because those words change what a likely continuation looks like.

What an LLM is not

A few myths, gently crushed:

Myth Friendlier truth
“It understands like I do” It models patterns in text very well. That can look like understanding.
“It browsed the live web just now” Only if a product wires search/tools in. The base model predicts from training + your prompt.
“It remembers me forever” Usually it only “remembers” what is in the current context (or what an app stores for you).
“It never makes mistakes” It makes fluent mistakes. Fluency is the product and the hazard.

A tiny end-to-end picture

  1. You write a prompt.
  2. Text becomes tokens.
  3. The model scores “what token should come next?”
  4. A token is chosen and appended.
  5. Repeat until it stops (or hits a limit).
  6. Tokens are decoded back into text you can read.

That is an LLM chat, under the hood, without the scary diagrams from research papers.

What to remember

If you forget everything else, keep this:

  1. LLMs predict the next token, again and again.
  2. Tokens are chunks of text, not always whole words.
  3. Training teaches patterns; inference uses them.
  4. Fluent answers can still be wrong — check important stuff.
  5. Prompts steer the continuation; clearer prompts help.

You do not need to become a researcher to use these tools well. You just need a mental model that matches reality: not a magical brain in a box, but an extraordinarily well-trained guessing engine for language — and guessing, it turns out, can get you surprisingly far.

Further reading