Reset your
AI literacy.

Strip away the magic and there's a single move: guess the next chunk of text, then do it again. Everything a chatbot does is that loop, running very fast.

Give it a few words and it produces a ranked list of what could come next, each with a probability:

   "The sky is"
        ↓
     [ model ]
        ↓
   blue      85%
   clear      6%
   grey       4%
   falling    0.1%

Made-up numbers, to show the shape — not a reading from a real model.

It picks one — leaning toward the likely ones, with a little randomness so you don't get an identical answer every time — adds it to the end, and feeds the whole thing back in:

"The sky is" → "The sky is blue" → "The sky is blue today" → ...

That's the entire engine. No plan, no meaning, no looking ahead — just the next chunk (a token), over and over, until it stops.

Try it yourself. Hit Predict — it reads the words so far, shows the odds for what comes next, picks one (leaning to the likely ones), and appends it. Then it runs again on the longer sentence:

import random

# a toy "model": for this context, what tends to come next
model = {
    "the sky is":      {"blue": 0.85, "clear": 0.10, "grey": 0.05},
    "the sky is blue": {"today": 0.6, "and": 0.3, ".": 0.1},
}

def next_word(context):
    options = model.get(context.lower())
    if not options:
        return "."
    words, probs = list(options.keys()), list(options.values())
    # pick one, weighted by probability
    return random.choices(words, weights=probs)[0]

text = "The sky is"
for _ in range(2):
    text += " " + next_word(text)
    print(text)

What a real LLM does differently:

· No lookup table — billions of learned numbers (weights) compute the probabilities instead.

· Its context is the whole conversation, not three words.

· It learned those numbers by reading enormous amounts of text and adjusting until its guesses matched what actually came next. That's training.

A model can't do math on letters, so text becomes numbers in two steps.

Step A — tokenize. Chop the text into chunks (tokens) and give each an ID from a fixed dictionary:

"The sky is blue"
   →  ["The", " sky", " is", " blue"]
   →  [ 464,   6766,   318,   4171 ]

Illustrative IDs — the exact numbers depend on the tokenizer.

Tokens aren't always whole words — "unbelievable" might split into "un", "believ", "able". (That's why you're billed per token, not per word.)

Step B — embed. Each ID becomes a list of numbers (a vector) that stands in for its meaning. Similar words land on similar vectors:

" blue" → [ 0.2, -0.9, 0.4, ... ]   real ones are ~1000s long
" red"  → [ 0.3, -0.8, 0.5, ... ]   ← near "blue"  (both colours)
" dog"  → [-0.7,  0.1, 0.9, ... ]   ← far away     (not a colour)

Illustrative numbers — the closeness is the real point.

Because meaning now lives in numbers, you can literally do arithmetic on it. The classic result from early word-vectors: king − man + woman ≈ queen.

Why that makes sense. Each number is like a dial for some property. Picture just two dials — "royal?" and "female?" — and read the words off them (real vectors have ~1000s, and they don't come with tidy labels, but the geometry is real):

             royal?   female?
king      =    0.9      0.0
man       =    0.1      0.0
woman     =    0.1      1.0
queen     =    0.9      1.0     ← what we hope to land near

king − man          =   0.8     0.0    "male" cancels; royalty stays
king − man + woman  =   0.9     1.0    ← lands right on queen

Subtracting "man" strips out the everyday-male part and leaves the royalty; adding "woman" puts the female part back — so the result sits right next to "queen." Nobody defined a "royalty" dial; that direction just fell out of training, because kings and queens are described in similar ways minus the gender.

The catch: a word's meaning depends on the words around it. In "the bank of the river" versus "money in the bank," the same token means two different things.

Attention lets every word look at every other word and pull in what's relevant. Take the word "it":

"The dog ignored the bone because it was full"
                                       ↑
                what does "it" mean?  →  "dog"  (bones aren't full)

attention for "it":
   dog     ██████████  0.80   ← looks mostly here
   bone    ██          0.15
   full    █           0.05

Illustrative scores — the mechanism is real; the exact weights are learned.

The model works out "how much should this word pay attention to each other word?", then blends their vectors together, weighted by those scores. Now "it" carries the meaning of "animal." Do that for every word, all at once — that's the Transformer.

How it all fits together:

text → tokens → embeddings → [ attention block ] ×dozens → next-token odds
                                    ↑ stacked deep — where context gets woven in
  ↑                                                                     ↓
  └─────────────── loop: append the token, run it again ───────────────┘

Where the intelligence actually comes from: nobody writes these rules. Every vector and attention weight is learned — during training the model reads text, guesses the next token, checks whether it was right, and nudges billions of numbers to be a little less wrong, across an enormous amount of text. The skill emerges from the guessing game — which is also why it has no beliefs of its own, only patterns pulled from what it read.

We keep saying "the weights are learned." Here's the actual mechanic — one big guess-and-correct loop. A single step:

1. Hide the answer:   "The sky is ___"      (true word: "blue")

2. Model guesses, using its current weights:
      grey   60%
      blue   30%    ← only gave the right word 30%
      green  10%

3. Measure how wrong it was  →  the LOSS
      "blue" should've been ~100%, got 30%  →  loss is high

4. "Which weights, nudged which way, would push 'blue' up?"
      → answering that is BACKPROPAGATION  (just the chain rule)
      → the answer is the GRADIENT: a direction for every weight

5. Nudge every weight a tiny step that way  →  GRADIENT DESCENT

6. Repeat — over and over, across trillions of words.

Illustrative percentages — the loop is the real point.

The picture: you're on a foggy hillside trying to reach the lowest valley (lowest loss). You can't see the bottom, but you can feel which way is downhill — so you take a small step that way, and repeat.

loss
 │＼
 │  ＼___          each step = one nudge downhill
 │      ＼__
 │         ＼____  "trained": loss is low, guesses are good
 └──────────────── weights

weight = 5.0            # start somewhere
rate   = 0.1            # step size (the "learning rate")
for step in range(40):
    gradient = 2 * weight       # downhill direction for loss = weight**2
    weight  -= rate * gradient  # step downhill
print(round(weight, 3))         # → ~0.0, the valley floor

Every one of a model's billions of weights gets this treatment. That "read everything and adjust" phase is pretraining — expensive: months on thousands of GPUs. The result is dazzling at completing text — but it isn't an assistant yet. Ask it a question and it might just reply with more questions, because that's what it saw on the web.

Pretraining gives you a brilliant text-completer, not an assistant. Two more — much cheaper — stages add the manners on top.

Stage A — Fine-tuning (SFT). Show it thousands of example conversations written by people: good question → good answer. Same guess-and-correct loop, but now it's learning the shape of being helpful.

"How do I boil an egg?"
  before →  "How do I fry an egg? How long do you..."   (just continues text)
  after  →  "Put it in boiling water for about 8 minutes."   (answers)

Stage B — RLHF (learning from preferences). The model writes two answers; a person — or a reward model trained on people's ratings — picks the better one; the model is nudged toward that. Do it a lot and it learns to be helpful, honest, and to decline harmful requests.

"Tell me a joke."
  A: "No."                                 ← person prefers B
  B: "Why don't scientists trust atoms?    ← nudge the model toward this
      They make up everything."

The whole lifecycle:

random weights
   │  Pretraining       read ~the internet, predict next token  → knows language & facts
   │  Fine-tuning (SFT)  copy human example conversations        → answers instead of rambling
   │  RLHF              nudge toward human-preferred answers     → helpful, safe, well-mannered
   ▼
  the assistant you're talking to

Put the four deep-dives together and that's the whole thing:

· Run time: tokens → embeddings → attention → predict the next token, loop.

· Train time: guess → measure loss → backprop → gradient descent, loop.

· Polish: fine-tune on examples, then RLHF on preferences.

No hidden magic layer — it's next-token prediction, scaled up and steered.

Want to watch it happen? Andrej Karpathy's makemore and nanoGPT are tiny, readable models you can train yourself and watch the loss drop.