Nineteen concepts in five sections: what a model really does, how to brief it, how to give it your knowledge, how it uses tools, and how to automate a whole job with it. One game each.
Section 1
Meet the machine
What an LLM actually is, and what it isn't.
Playable 4 min
Next-word prediction
A large language model (LLM) writes one small piece of text at a time. At every step it scores every possible next piece by how likely it is to follow what came before, and picks one.
The game: Be the Model
You are the model. Read the start of a sentence, bet on the word that comes next, and see the real odds. Then find out what happens when the sentence asks for something the model can't know.
Why it matters
It explains both its talent and its flaw. An LLM is brilliant at fluent, plausible text (drafts, rephrasing, summaries), and it will produce plausible text even when it doesn't know the answer. Plausible is not the same as true.
Coming soon 4 min
Tokens
Models don't read letters or words: they read tokens, chunks of a few characters. Everything is counted in tokens: what you send, what it writes, what it costs, and how much it can hold at once.
The game: Token Butcher
Slice sentences where you think the model does, then guess the token count of an email, a contract and a spreadsheet before the meter reveals it.
Why it matters
Tokens explain the bill (long documents cost more), the limits (how much fits in one conversation) and some odd failures (counting the r's in “strawberry” is hard when you never see letters).
Playable 5 min
Temperature
At each step the model has a list of likely next words, each with its odds. Temperature decides how adventurous it is when it picks: low means “almost always take the favourite”, high means “give the outsiders a real chance”.
The game: The Dial
Turn the dial and watch the odds reshape. Make the model say the same thing five times in a row, then five different things, then set the dial right for six real office jobs.
Why it matters
Some questions deserve a predictable answer (extracting an amount, classifying a ticket), others a surprising one (naming a product, brainstorming). Knowing which one you need tells you how to ask, and explains why the same prompt can give two different answers.
Coming soon 4 min
Hallucinations
When the model doesn't know, it doesn't say so by default: it carries on with what sounds right. Invented references, wrong figures and confident nonsense are called hallucinations.
The game: Fact or Fabrication
Model answers come in fast. Mark each claim “backed by the source” or “invented” before the timer runs out, then fix the prompt that produced them.
Why it matters
Knowing the tells (very precise numbers, names and sources you never provided) and the cure (give it the source, ask it to quote it, allow it to say “I don't know”) is the difference between a useful assistant and a liability.
Side path · optional, technical
Under the hood
How the guessing machine is built: neurons, weights, and how it learns.
Playable 8 min
Neural networks
The odds a model gives every next word are computed by a neural network: layers of tiny units called neurons, each weighing its inputs and passing a number on. A neuron is a weighted vote; a network is billions of them, wired in layers.
The game: Neuron Lab
Wire a neuron by hand: set its weights so it makes the right decisions, watch it learn them by itself, then meet the decision no single neuron can make.
Why it matters
It takes the magic out: no rules, no database of answers, just numbers (weights) tuned on examples. That's why a model is good at what its examples covered, and odd at what they didn't.
Coming soon 6 min
How a network learns
Nobody sets a model's weights by hand. Training shows it an example, measures how wrong its guess was, and nudges every weight a little in the direction that would have made it less wrong. Then again, trillions of times.
The game: Downhill
Roll a ball down a landscape of mistakes, one nudge at a time, and find the valley where the model guesses best, without overshooting it.
Why it matters
It explains what a model knows (what was in its training text, up to a date) and what it doesn't (your files, last week, anything private), and why it gets better with more and better examples.
Section 2
Talk to it
Prompting: getting what you meant, not what you said.
Playable Real model 10 min
Anatomy of a prompt
A good prompt is a good brief: the task, the material to work on, what the result must look like, and the rules to follow. The model only knows what you put in it.
The game: Prompt Lab
Three real briefs, a real model. Write the prompt, run it, and watch the checks turn green or red. Start from a lazy prompt and improve it until every check passes.
Why it matters
The gap between “summarise this” and a real brief is the gap between an answer you rewrite and one you send. It is the single most useful AI skill at work.
Coming soon 5 min
The context window
A model has no memory between messages. Each time, it is sent the conversation again, and that must fit in a fixed budget of tokens, its context window. When it is full, the oldest parts are left out.
The game: Memory Lane
A conversation scrolls through a window of fixed size and messages fall off the top. Answer what the model can still see, and pin the facts that must survive.
Why it matters
That's why a long chat “forgets” the instruction you gave at the start, and why a fresh conversation with a good brief often beats a very long one.
Coming soon Real model 6 min
Instructions & personas
Before your message, an assistant usually gets standing instructions: who it is, how it writes, what it must never do. Same model, different instructions, a very different assistant.
The game: Persona Match
One question, four answers, four hidden sets of instructions. Match each answer to its instructions, then write the instructions that produce a fifth.
Why it matters
Instructions written once and reused turn a generic chatbot into a colleague who already knows how your team writes and what your clients expect.
Coming soon 5 min
Teaching by example
Showing beats telling. A few examples of an input and the output you want, placed in the prompt, teach the model your format and your judgement faster than paragraphs of rules.
The game: Show, Don't Tell
A ticket sorter keeps getting it wrong. Choose which examples to show it and watch its score on twenty hidden tickets climb, or crash when your examples mislead it.
Why it matters
Sorting tickets, tagging expenses, writing in the house style: two or three good examples are often all the “training” a task needs.
Section 3
Give it your knowledge
Your documents, your data, your formats.
Coming soon Real model 6 min
Structured answers
Instead of a paragraph, you can ask for named fields: supplier, amount, due date. The answer then drops into a spreadsheet, a form or the next step of a workflow, with no copy-paste.
The game: Form Filler
Invoices, emails and CVs pour in. Design the fields (a name, a kind, a one-line description) so every document fits, and find the documents that break your form.
Why it matters
Fields turn an AI reply into something a process can use: filtered, totalled, routed.
Coming soon 5 min
Meaning, as numbers
An embedding turns a text into a long list of numbers that captures its meaning. Texts that mean the same thing get similar numbers, even with no word in common.
The game: Meaning Map
Place sentences on a map so those that mean the same thing sit together, then race the machine's own map to the right document.
Why it matters
It is how search by meaning works: finding the clause about “termination” when it says “ending the agreement”. It's the engine under most “chat with your documents” tools.
Coming soon 6 min
Retrieval (RAG)
Retrieval-augmented generation: before answering, fetch the few passages that matter from your documents and put them in the prompt. The model then answers from them, not from memory.
The game: The Librarian
Questions arrive at the desk. Choose which documents to hand the model before it answers. Too few and it invents; too many and the answer drowns, and the bill grows.
Why it matters
It is how an assistant answers questions about your policies, projects and clients, and why its answers can point to their source.
Section 4
Let it act
Tools and agents: from talking to doing.
Playable 6 min
Tools
A model can't open your calendar or read a spreadsheet. But it can ask: given a list of tools, it writes “call this tool with these arguments”, the app runs it, and the result goes back to the model.
The game: Toolbelt
Requests come in, and you are the model. Pick the right tool (or none), fill in its arguments, and chain two tools when one isn't enough.
Why it matters
Tools are how AI goes from writing about your work to doing it: finding the file, reading the numbers, drafting into the right document. Your request is the only clue it has to pick the right tool with the right arguments.
Coming soon 6 min
The agent loop
An agent is a model in a loop: decide what to do, call a tool, look at the result, decide again, until the job is done or it runs out of steps.
The game: Think, Act, Look
Drive an agent through a messy task with a limited number of steps. Each turn: think, act, read what comes back. Waste steps and the job is left half done.
Why it matters
It's what lets AI take on a task with unknowns (“find last quarter's report, compare it with this one, flag what changed”) rather than a single question.
Coming soon 4 min
Asking first
Some actions are cheap to undo and others aren't. A well-built agent asks before it sends, deletes or overwrites, and a well-trained person knows what to approve.
The game: Approve or Deny
Tool calls stream in from a busy agent. Approve the harmless ones, stop the dangerous ones, and catch the one that only looks harmless.
Why it matters
You get the speed of automation without handing over the keys: the agent prepares, you decide.
Coming soon 5 min
Handing off
Several specialised agents often beat one generalist: a writer, an analyst, a reviewer. A handoff passes the conversation to the right specialist.
The game: Dispatch
Requests pile up at the switchboard. Send each to the right specialist agent, and catch the ones that need two of them in turn.
Why it matters
Specialists with short, focused instructions make fewer mistakes than one agent asked to be good at everything.
Section 5
Automate it
Workflows: AI steps that run without you.
Coming soon 6 min
Steps & variables
A workflow is a chain of steps. Each step is a prompt, and {{variables}} carry what earlier steps wrote into later ones: {{research}}, {{previous}}, {{today}}.
The game: Plumber
The pipes are laid but the labels are missing. Wire each {{variable}} so every step gets what it needs, and see what the last step writes when one is wrong.
Why it matters
A workflow does the same multi-step job the same way every time (research, draft, format) without you copy-pasting between chats.
Playable 8 min
Branches
An if/else step asks a yes-or-no question in plain words (“Is this an invoice to pay?”) and the workflow goes one way or the other. Because a model answers it, the question can be about meaning, not keywords.
The game: Sorting Office
Eight emails, four destinations, one canvas. Build the graph of yes/no questions that sends every email where the office rules say, then run it and watch each one travel.
Why it matters
Branches let one workflow handle a mixed inbox: invoices to finance, emergencies to the team, the rest to a drafted reply, each item down the right path.
Coming soon 5 min
Triggers
Something has to start a workflow: you, by hand; a schedule (every hour, every weekday at 9:00); or an event, such as a message arriving.
The game: Clockwork
Ten jobs, four ways to start them. Set the trigger for each, fast-forward a week, and see what ran, what ran too often, and what never ran.
Why it matters
The right trigger is what turns a useful workflow into one that quietly does its job every day without anyone remembering to run it.
Coming soon Real model 15 min
Boss level: the Morning Brief
Everything together (inputs, agent steps, fields, branches and a trigger) in a workflow you would really use.
The game: The Morning Brief
A manager wants a brief every weekday at 8:30: overnight emails summarised, invoices flagged, anything urgent on top. Design it, test it against a week of mornings, and ship it.
Why it matters
This is where AI stops being a chat window and becomes part of how your work runs.