AI glossary

Every term below is taught properly inside a lesson — plain English first, the technical name second. This page is a reference, not a shortcut: the lessons show why each distinction matters.

Prediction machine (series' core mental model — Lesson 1)

Our name for what a generative AI model actually is: a system that produces output by repeatedly predicting what plausibly comes next, based on patterns learned from examples. Not a database, not a search engine, not a mind.

Generative AI (Lesson 1)

AI systems that produce new content — text, images, audio — rather than only sorting or scoring existing things. This series focuses mainly on generative AI.

Training data (Lesson 2)

The enormous collection of examples (web text, books, code and more) from which a model's patterns were learned. What's thick in the data, the model does well; what's thin or missing becomes a blind spot. The model does not keep the documents themselves — it keeps the tendencies they induced.

Token (Lesson 3)

The machine's unit of text: a frequent chunk of characters from a fixed catalogue, often smaller than a word. Models read, write, and are priced and limited in tokens — which also explains why they can struggle to count letters inside a word.

Probability distribution (Lesson 4)

At every step the model scores every token in its catalogue as a candidate for what comes next — a ranked list from very likely to absurd. The answer you see is drawn from this list, one token at a time.

Temperature (sampling) (Lesson 4)

A setting that reshapes how the next token is drawn from the candidate list. Low: consistent, sometimes flat. High: varied, sometimes inspired, sometimes unreliable. It's why the same question can get different answers — by design, not malfunction.

Training (and weights) (Lesson 5)

How the model's skill was built: guess the next token, compare with reality, nudge billions of internal settings (the weights) a tiny amount, repeat at vast scale. Once training stops, the weights freeze — using a model is not training it.

Neural network (Lesson 6)

Layers of simple arithmetic — multiply by learned weights, add, pass on — stacked dozens deep. The name honours a loose 1940s biological inspiration, not a brain in a box. No single weight holds any rule; behaviour is spread across billions of them.

Embedding (Lesson 7)

A token's (or sentence's) coordinates in a learned meaning-space, where distance tracks similarity of use. The trick behind semantic search: "laptop won't turn on" sits near "computer fails to boot" with zero shared words. Nearness means "used alike" — not "correct".

Attention (and transformer) (Lesson 8)

The mechanism where every token scores its relevance to every other token, letting context reshape meaning ("bank" drifts riverward or moneyward). A transformer stacks many parallel attention scans dozens of layers deep — the 2017 architecture behind today's mainstream AI.

Inference (Lesson 9)

Using the trained, frozen model to produce an answer: the whole pipeline runs once per token, and the growing answer feeds back in. Performing, never practising — and metered per token, which is why long answers cost more.

Hallucination (Lesson 17)

When a model produces plausible-sounding content that isn't true. Not a rare glitch: it's the normal prediction process operating where its evidence is thin — specific checkable details and thin-coverage topics are the highest-risk territory. Fluent confidence is a learned style, not a truth signal.

Bias (AI bias) (Lesson 18)

Patterns of unequal portrayal or performance inherited from training data, feedback tuning and provider design choices — not malice, and not eliminated by "being mathematical". Consistency is not the same as objectivity. Often shows up as unequal error rates across groups, invisible in any single output and only visible across many.

Agent (Lesson 16)

A model given a goal and permission to loop: plan, act via a tool, observe the result, revise, repeat — until it judges the goal met. The same prediction machine and the same tool-use pattern (Lesson 14), composed into a cycle. Small per-step error rates compound across many autonomous steps, which is why gates, caps and reviewing the trace matter more than the model's "intelligence".

Prompt injection (Lesson 19)

Hostile instructions hidden inside content an AI system reads — a webpage, document or email — which the model's desk treats as just more context, with no privileged channel telling trusted instructions apart from ingested text. With tools attached, an injected instruction can trigger real actions; with memory, it can persist.

Context window (Lesson 10)

The fixed budget of tokens a model can use for the current response — the "desk" holding your conversation, pasted documents and the provider's hidden instructions. Most "it forgot" moments are material dropping off this desk, not memory decay.

Prompt (and prompting) (Lesson 11)

What you type to steer a model's continuation. Not a command to an obedient mind — context that reshapes which candidates on the probability list look most plausible. A well-briefed prompt states the objective, supplies context, sets constraints, shows an example, and says how to handle uncertainty.

Retrieval-augmented generation (RAG) (Lesson 13)

Bolting a search step onto the pipeline: find passages relevant to the question, place them on the desk, then generate an answer from them, with citations. Reduces — but does not eliminate — fabrication; a citation proves a passage was fetched, not that it's current or faithfully represented.

API and tool use (Lesson 14)

An API is a set form another program accepts. Tool use is the model writing a structured request in that form — a "work order" — for ordinary software (a calculator, a calendar, a live database) to execute exactly, with the result returned to the desk. The model gained a dialling pattern, not the tool's abilities.

Memory (assistant "memory" features) (Lesson 15)

An engineered notebook outside the frozen model: the surrounding system extracts facts worth remembering from your chats, stores them, and loads relevant ones back onto the desk in later conversations. Readable, editable and deletable — not a change to the model's weights, and not the model "learning" you.