What an LLM Actually Is

⏱ ~6 min read · 🎧 5 min listen · ✎ 3 quizzes · 🧪 ~15 min exercise

You're going to spend your career building reliable systems on top of these models for customers. You cannot make something reliable if you don't know what it is. So we start with the one mental model that the rest of the course hangs off — the one that lets you look at a weird model behavior at a client site and say "of course it did that," instead of being surprised.

The whole thing, in one sentence

An LLM is a function that takes some text and outputs a probability distribution over what the next token should be.¹ That's it. That is the entire machine.

A token is just a chunk of text — usually part of a word. To generate a full answer, the model runs a loop you already understand as an engineer:

text = "The capital of France is"
loop:
    dist  = model(text)        # a probability for every possible next token
    next  = sample(dist)       # pick one, e.g. " Paris"
    text  = text + next        # append it
    if next == END: break      # stop token

Predict a token, glue it on, feed the whole thing back in, predict again. This loop is called autoregression, and running it fast is all that happens when you call ChatGPT or Claude.² There is no database lookup, no reasoning module, no fact-checker. One loop.

Why an FDE should care: four behaviors fall out for free

Here's the payoff. You don't have to memorize the model's quirks as a list — you can derive them from "it samples plausible next tokens from compressed text patterns."

1. It hallucinates — and that's not a bug

The loop always produces a plausible continuation. Plausible ≠ true. If a customer asks for a policy number the model never saw, the most plausible next tokens still look like a policy number — so it confidently invents one.³ Hallucination isn't a defect bolted on; it's what next-token prediction does when it lacks the fact. (Grounding it in real data — RAG — is a later lesson, and now you'll know exactly why it works.)

2. Same prompt, different answers

The model outputs a distribution; sample() picks from it. Turn the temperature up and picks get more random; down toward zero and they get near-deterministic. This is why an LLM call is not a pure function the way your other code is — a fact that will shape how you test and eval it.

3. It has no memory between calls

The only thing the model sees is the text in front of it — the context window. It doesn't "remember" your last message unless you resend it. Every bit of customer context the model needs must be in the input. "Chat history" is just your app re-pasting the conversation each turn.

4. Wording matters more than you'd expect

Output is conditioned entirely on input tokens, so changing the prompt changes the distribution. This isn't the model being fussy — it's the mechanism. It's also why prompt engineering is a real lever, not folklore (Lesson 03).

Check yourself — diagnose the failure

Retrieval beats re-reading. Don't scroll up: for each customer scenario, name the root cause from the model itself. Wrong picks stay live — try again.

You are a senior AI engineer reviewing my work: my written diagnoses of three customer scenarios (a bot citing a nonexistent policy clause, identical prompts giving different answers, and a bot "forgetting" a detail from earlier in a long conversation). I've explained each failure in my own words, tracing it back to how an LLM actually works.

Grade each diagnosis as Strong / Adequate / Missing, with one sentence of evidence:
- Every explanation traces to the mechanism: the model samples plausible next tokens from compressed text patterns.
- Hallucination is framed as inherent to next-token prediction when a fact is absent — not a bug or misconfiguration.
- Non-determinism is attributed to sampling from a probability distribution (and I mention temperature's role).
- "Forgetting" is attributed to the context window — text that scrolled out is invisible, not deleted.

Be skeptical — challenge my weakest diagnosis first. Then ask me 2–3 follow-up questions a customer would ask in the room. Finish with the single highest-leverage improvement to my mental model.

My work follows below.