Learn LLMs: From Zero to Transformer

What you will be able to do

By the end of this course you will be able to explain, in plain language and in technical detail, what happens between the moment you type a prompt and the moment a language model answers. You will understand tokens, embeddings, training, fine-tuning, attention, and the famous Transformer architecture — and you will have poked at each of these ideas with live, interactive demos rather than just reading about them.

This is not a coding course. You will not need to install anything or write a single line of Python. Instead, every important idea is paired with a small lab you can play with directly on the page, so the abstract concepts become things you can see and manipulate.

The learning path

The course climbs through four difficulty tiers. Each tier has a colour you will see throughout — on the module list, on the tier dots, and in the diagrams.

Ready? Open Module 1 from the sidebar, or hit the button below to begin with the single most important idea in the whole course.

A quick orientation to the visual language of this course so nothing trips you up later.

Interactive labs

Whenever you see a panel with a glowing dot and a LAB label, it is live. Click buttons, drag sliders, and watch the numbers change. The labs are simplified models — a real LLM has billions of parameters, not the handful shown — but the mechanism they demonstrate is exactly the one used at scale.

Colour means something

Colour is used consistently to encode the four recurring ideas of the course, so you can recognise them at a glance:

The four kinds of callout

Hover for definitions

Words with a dotted underline like token have a quick definition when you hover. The full glossary lives in the Capstone module at the end.

Before any mathematics, here is the whole idea of a language model in a single story.

Imagine a man named Peter who owns a clever parrot called Buddy. Buddy has a remarkable talent for mimicry and a sharp memory. All day he listens to the conversations in Peter’s home, and he learns to continue them. When Buddy hears “I’m feeling hungry, I would like to have some…”, the words most likely to come out of his beak are things like biryani, cherries or food — not bicycle or book.

Here is the crucial part: Buddy has no idea what biryani is. He has never tasted it and does not know it is a meal. He is simply reproducing patterns, choosing whichever next word tends to follow, with a dash of randomness so he doesn’t say exactly the same thing every time.

A language model is, at heart, exactly this kind of parrot built out of software. It uses a technology called a neural network to predict the next word or words in a sentence. Train it on a particular kind of text and it will continue that kind of text. Feed a model every movie article on Wikipedia, and it becomes very good at finishing movie-related sentences.

You have almost certainly used one already. When Gmail finishes your sentence before you do, a language model is doing the predicting underneath.

Same parrot, vastly more experience. That is essentially the leap from a language model to a large language model.

Suppose Buddy is granted a kind of superpower and can now hear not just Peter’s home, but conversations in every school, university and town — across the entire world. With that much exposure, Buddy can suddenly finish a sentence about history, offer nutrition advice, or compose a poem. Nothing about his method changed. The scale of what he has heard is what transformed him.

A large language model (LLM) is a language model trained on an enormous volume of text: Wikipedia, news archives, online books, code, and much of the public internet. Peer inside one and you find a neural network with billions or even trillions of parameters, enough to capture extremely subtle patterns and nuances of language.

Some names you will recognise:

• GPT-3 / GPT-4 — the models behind ChatGPT, from OpenAI.
• PaLM and PaLM 2 — from Google.
• LLaMA — from Meta, notable for its openly released weights.

Different builders, different training data, but all the same underlying recipe: a very large neural network trained to predict text.

The single most useful way to think about an LLM: it is autocomplete that got extremely good.

Give a model the text “It’s raining cats and…” and it will predict that dogs is the most likely continuation. That sounds trivial — but notice that every task we throw at these models is secretly this same task. Ask a question and the most likely continuation of a well-posed question is its answer. Ask for a translation and the likely continuation of an English sentence under a “French:” heading is the French version.

Try it yourself. Pick a starting phrase, then click any of the predicted next words to keep the sentence going. The bars show how likely the model thinks each option is.

Two things are worth noticing as you play:

• Randomness makes it feel natural. If the model always picked the single most likely word, its writing would be flat and repetitive. Allowing it to occasionally choose a less-likely word produces more human-sounding text.
• The same prompt can give different answers. Because of that sampling, running the identical prompt twice often yields different results — even though the underlying function is completely fixed and deterministic.

A model that perfectly imitates the internet is not yet a helpful, polite assistant. Fixing that gap is its own kind of training.

Back to Buddy. One day Peter overhears the parrot snapping something harsh at his two-year-old son — words Buddy clearly picked up from the more abusive households in town. Buddy didn’t invent the cruelty; he absorbed it, because he absorbs everything.

So Peter starts supervising. For a given prompt, he has Buddy produce several possible responses, and he simply tells him which ones are acceptable and which are toxic. Over time, Buddy learns to avoid the bad patterns and lean on the good ones. The parrot’s raw knowledge didn’t change — his behaviour did.

This is precisely how a raw text-predictor is turned into something like ChatGPT. The base model learns language by reading the internet; then a large workforce of human reviewers helps shape it to be more helpful and far less toxic. The goal of “autocomplete a random web page” is genuinely different from the goal of “be a good assistant” — and bridging those two goals is what this extra training does.

You now hold the foundational mental model for the entire course. Lock it in.

Answer these to confirm the ideas are solid, then continue to Module 2 where we trace where these models came from.

Today’s models did not appear from nowhere. They are the latest step in a long climb.

In the 1960s, a program called ELIZA imitated a psychotherapist by matching keywords and reflecting your sentences back at you. It could feel eerily conversational, but there was no learning involved — just hand-written rules. For decades, language software stayed largely rule-based and brittle.

Later came statistical language models that learned word probabilities from text, and then recurrent neural networks (RNNs), which read a sentence one word at a time, carrying a running memory forward. RNNs were a real advance, but they had two stubborn problems: they processed words strictly in sequence (slow, hard to parallelise), and they tended to “forget” information from early in a long passage by the time they reached the end.

Why did that matter so much? Two reasons:

• Parallelism. Reading everything at once fits beautifully on modern hardware (GPUs), so Transformers could be trained on far more data, far faster.
• Long-range context. The mechanism called attention lets a word at the end of a paragraph pull information directly from a word at the beginning, with no fading memory.

A quick field guide to the names you keep hearing — and a feel for the staggering growth in size.

Most well-known models are pre-trained once at great expense and then adapted to many uses. They fall into a few families:

• GPT (OpenAI) — “Generative Pre-trained Transformer.” GPT-1, 2, 3 and 4 mark a steady escalation in scale and capability. GPT-3 famously has 175 billion parameters.
• BERT (Google) — an earlier, influential model focused on understanding text (for search and classification) rather than open-ended generation.
• PaLM / PaLM 2 (Google) and Gemini (Google) — large general-purpose models.
• LLaMA (Meta) — a family whose weights were released openly, fuelling a wave of community models.
• Claude (Anthropic) and others — the landscape now has many capable players.

Explore the timeline below. Click any model to see what set it apart, and notice the parameter-count chart — it is drawn on a logarithmic scale because the raw numbers grew too fast to fit otherwise.

These terms get thrown around interchangeably. Here is how they nest.

Picture a set of boxes inside boxes:

So every LLM is deep learning, which is machine learning, which is AI — but not every AI is an LLM.

This is the deep shift from older machine learning. Traditionally you trained one narrow model per task: one to tell if a tweet is positive or negative, another to translate French to English. An LLM flips that: a single general model handles chat, summarising, translation, brainstorming, code generation and far more — because it learned the underlying structure of language rather than one specific job.

You can now place LLMs in time and in the wider map of AI.

A model cannot read letters. The very first thing it does to your prompt is chop it into tokens.

A token is the basic unit an LLM reads and predicts. It is often a whole word, but just as often it is a piece of a word. Common words like the usually become a single token; a rarer or longer word like tokenization may be split into several pieces such as token + ization.

Why split words at all? It is a compromise. If every token were a full word, the vocabulary would be gigantic and the model would choke on any word it had never seen. If every token were a single letter, sequences would become impossibly long. Splitting into common sub-word pieces — a scheme called byte-pair encoding (BPE) — gets the best of both: frequent words stay whole, and unusual words are still representable by assembling pieces.

Type anything below to see how it tokenizes. Watch what happens with spaces, capital letters, numbers and unusual words.

Tokenization quietly explains several of an LLM’s strangest quirks:

• Spelling and counting letters. Ask a model how many R’s are in “strawberry” and it may stumble — because it never saw the individual letters, only a couple of chunky tokens. The letters are hidden inside the token.
• A leading space matters. dog at the start of a sentence and ␣dog after a space are often different tokens with different IDs.
• Arithmetic on digits. Numbers get split in awkward ways, which is part of why naive models struggle with long multiplication.

A token ID is just a label. The real magic is the long list of numbers attached to each token — its embedding.

Once your text is a list of token IDs, the model looks up each ID in a giant table and replaces it with a vector — a long list of numbers. In GPT-3 each of these lists has 12,288 numbers. You can think of every token as a point in a space with that many dimensions. We obviously can’t picture 12,288 dimensions, so the lab below flattens it to two.

Explore the embedding space below. Each dot is a word; notice how related words cluster, and how certain directions seem to carry consistent meaning.

This is the deepest idea so far: there is no dictionary inside the model defining “king.” There is only a vector, positioned among all the other vectors. Its meaning is its set of relationships to everything else — how close it sits to “queen,” “throne,” “crown,” and how far from “banana.”

If meaning is geometry, then you can do arithmetic on meaning. This is where embeddings stop feeling like a trick and start feeling profound.

Because directions in the embedding space carry meaning, you can sometimes add and subtract concepts. The famous example: take the vector for king, subtract the vector for man, add the vector for woman, and you land remarkably close to queen.

Read that as a sentence about directions: the step from “man” to “woman” is roughly the same step, in the same direction, as the step from “king” to “queen.” The model discovered a “gender direction” on its own, simply from reading text. Similar consistent directions appear for plurals, verb tenses, and even country–to–capital relationships.

How the model measures similarity: the dot product

To compare two vectors, models lean on an operation called the dot product. You multiply the two lists of numbers element by element and add up the results. The intuition is simple:

• Vectors pointing the same direction → large positive dot product (“very related”).
• Vectors at right angles → dot product near zero (“unrelated”).
• Vectors pointing opposite ways → negative dot product (“opposed”).

This one little operation — “how aligned are these two vectors?” — is the beating heart of the attention mechanism you’ll meet in Module 6. Everything the Transformer does to relate one word to another is built from dot products.

Embeddings are not just an internal detail of LLMs — they power a whole category of useful tools on their own.

Because similar meanings sit close together, you can embed a whole sentence or document into a single vector and then search by meaning instead of by keyword. Ask “how do I reset my password?” and a semantic search can surface a help article titled “recovering account access” even though they share almost no words — because their vectors are close.

This sets up one of the most important practical patterns in the field, which we’ll fully explore in Module 8: Retrieval-Augmented Generation (RAG). The idea in one breath:

RAG is how you give a model access to private company documents or up-to-date information it was never trained on — without retraining it. The embeddings you just learned about are the first link in that chain.

You now understand how raw text becomes something a network can compute with.

Strip an LLM down and it is really just three things working together.

A useful equation: LLM = data + architecture + training.

• Data — the enormous body of text the model learns from: books, articles, conversations, code. “Large” is an understatement. GPT-3 was pre-trained on roughly 45 terabytes of text. To feel that scale: a single gigabyte of text holds about 178 million words, and a petabyte is about a million gigabytes. We are talking about a meaningful fraction of the written internet.
• Architecture — the neural network design that processes the data. For GPT, that design is the Transformer, built to handle sequences and to weigh each word in relation to every other word in the sentence.
• Training — the process of feeding the data through the architecture and adjusting the model so its predictions improve.

The next three lessons take these in turn: how training actually adjusts those billions of sliders, the almost unimaginable amount of computation it requires, and how a finished general model is then specialised and made polite.

Here is the actual learning loop — and it is built entirely on the next-word prediction you already understand.

No human ever sets those billions of parameters by hand. They start as random numbers, which means a fresh model outputs pure gibberish. Training then refines them, one tiny nudge at a time, using a beautifully simple loop:

The algorithm that performs step 4 — figuring out which direction to nudge each of billions of parameters — is called backpropagation. Repeat this loop for trillions of examples and something almost magical happens: the model not only predicts the training text well, it begins to make sensible predictions on text it has never seen. That generalisation is the whole point.

Run the loop yourself. The model is trying to learn that “the sky is” should be followed by “blue.” Watch the loss fall and the probabilities shift as you train it.

The loop is simple. Doing it enough times is one of the largest computations humanity has ever performed.

Consider the data side first. If a person read non-stop, 24 hours a day, the amount of text used to train GPT-3 would take them over 2,600 years to get through. Newer models train on far more still.

Now the computation. Imagine you could personally perform one billion additions and multiplications every single second. How long would it take you to do all the arithmetic involved in training a leading model? Not a year. Not ten thousand years. The answer is well over 100 million years.

A handy mental model: two files

One vivid way to picture a finished model: it is essentially two files.

• A parameters file — a giant list of all those learned weights. For an openly released 70-billion-parameter model, this file is around 140 gigabytes.
• A small piece of code that knows how to run those parameters — how to take your tokens and push them through the network to predict the next one.

That is genuinely most of what a local language model is: a big bag of numbers plus a few hundred lines of code to use them. All the “intelligence” lives in the numbers.

A freshly pre-trained model is a brilliant mimic of the internet — not yet a helpful assistant. Fine-tuning bridges that gap.

The model that comes out of pre-training is called a base model. It will happily continue any text, but it doesn’t naturally answer questions or follow instructions — ask it something and it might just generate more questions, because that is a plausible continuation of a list of questions on a web page.

Fine-tuning takes that base model and trains it further on a smaller, carefully chosen dataset. The mechanics are the same prediction loop as before — just with different, targeted examples. Two flavours matter:

• Task fine-tuning. Specialise a general model for one job — say, classifying medical notes, or writing in a company’s house style — by training it on examples of that task. This is what turns a generalist into an expert.
• Assistant (instruction) fine-tuning. Train the model on many examples of the form “here is a request, here is an ideal helpful response.” After enough of these, the model learns the behaviour of being a helpful assistant: when it sees a question, it answers.

The final polish that makes assistants genuinely usable: training directly on what humans prefer.

Instruction fine-tuning gets a model answering questions, but how do you push it toward answers that are more helpful, more honest, and less harmful — qualities that are hard to write down as fixed rules? You let humans judge.

The recipe, reinforcement learning from human feedback (RLHF), works in two moves:

This is exactly Peter correcting Buddy from Module 1, now industrialised: large teams of reviewers flag unhelpful or problematic outputs, and those judgements reshape the model. RLHF is a big part of why modern assistants feel cooperative and safe rather than like a raw, unpredictable text generator.

You now know how a pile of random numbers becomes a helpful assistant.

For four modules “the Transformer” has been a black box. Now we open it. Start with the name itself.

GPT stands for Generative Pre-trained Transformer — three words that each name a piece you already understand:

• Generative — it produces new text, one token at a time, rather than just classifying existing text.
• Pre-trained — it was first trained on a vast, general body of text (Module 4) before being adapted to specific uses.
• Transformer — the neural-network architecture underneath, the thing we are about to dissect.

Here is the journey your prompt takes through a Transformer, end to end. We’ll spend the rest of this module and all of the next walking each stage:

Steps 2 and 3 are stacked and repeated many times — dozens of layers deep. Let’s follow the data through.

Picture your tokens as a row of vectors flowing left-to-right through a tall stack of identical layers.

After embedding, your prompt is a sequence of vectors — one per token, side by side. This sequence then flows through many repeated blocks, and each block does two things in turn:

• An attention step, where the vectors exchange information — every token gets to look at the others and pull in relevant context. This is the only step where tokens influence each other.
• A feed-forward step (a small neural network applied to each vector independently), which gives the model extra capacity to store and apply patterns it learned during training. This is where a lot of the model’s factual “knowledge” is thought to live.

The same pair repeats, block after block. With each pass, the hope is that every vector gets enriched — soaking up more and more of the context and learned knowledge needed to predict what comes next.

This is the elegant core of the design: a simple, repeated motif — talk to each other, then think individually — stacked deep, transforms a plain row of word-vectors into a rich representation that “knows” what should come next.

A distinction that clears up a lot of confusion: what stays fixed in the model versus what changes with every prompt.

There are two very different kinds of numbers inside a running Transformer:

The weights are organised into a great many matrices — rectangular grids of numbers. “Running the model” mostly means multiplying your flowing vectors by these fixed weight matrices, over and over. That is why GPUs, which are built for matrix multiplication, are the natural hardware.

Those 175 billion weights are spread across roughly 28,000 matrices, grouped into a handful of categories — the embedding table, the attention matrices, the feed-forward matrices, and the final unembedding matrix, among others. Every one of them was tuned by the training process; none were set by hand.

The grand finale of every forward pass: how that last enriched vector becomes a probability for each possible next token — and how the “creativity” dial works.

After the final block, the model takes the last vector and multiplies it by one more big weight matrix — the unembedding matrix — producing one raw score for every token in the vocabulary. For GPT-3 that’s 50,257 scores. These raw scores are called logits. A high logit means “this token fits well here.”

But logits aren’t probabilities — they can be any size, positive or negative. To convert them into a proper probability distribution (all positive, summing to 1), the model applies a function called softmax. Softmax exponentiates each logit and then normalises, which has a nice effect: bigger logits become much bigger probabilities, while still leaving every token a tiny non-zero chance.

Play with it directly. The logits below are fixed; only the temperature changes. Watch how the same scores produce wildly different behaviour, then sample to see the practical effect.

You can now narrate the full forward pass of a Transformer.

Attention exists to solve one concrete problem: a word’s meaning depends on the words around it, but its starting embedding doesn’t know that yet.

Recall from Module 3 that each token begins with a context-free embedding — the generic meaning of the word in isolation. But words are slippery. Consider mole:

• a small burrowing animal,
• a unit of measurement in chemistry,
• a spot on the skin,
• a spy embedded in an organisation.

All four share one starting embedding, yet the correct meaning is entirely determined by context. The same is true of phrases: the word tower means something more specific once it’s preceded by Eiffel. For the model to predict well, it must update each word’s vector to reflect its actual surroundings.

This is also how the model handles relationships across a long span — an adjective at the start of a sentence colouring a noun at the end, or a pronoun like “it” figuring out what it refers to. Attention lets distant words reach each other directly, which is precisely what older sequential models struggled to do.

Attention is built from three vectors derived from each token. Understand their roles and the whole mechanism falls into place.

From each token’s current vector, the model computes three new vectors by multiplying it with three different learned weight matrices. Each plays a distinct role, captured well by a search analogy:

So the flow within attention is: derive Q, K, V for every token → use Q·K dot products to decide who should listen to whom → pass V’s accordingly. The next lesson turns those dot products into an actual attention pattern you can see.

Now we assemble queries and keys into the grid that defines a single attention head — and add the one rule that keeps generation honest.

Take every token’s query and dot it against every token’s key. The result is a grid of scores: for each pair of positions, how relevant is one to the other. Run each row through softmax (the same function from Module 5) and each row becomes a set of attention weights that sum to 1 — a clean recipe for how much each token should listen to every other token.

Explore one below. Pick a head preset to see different relational patterns, click a row (a query token) to highlight what it attends to, and toggle the causal mask to see its effect.

Masking: no peeking at the future

When a model generates text, it must predict the next token using only the tokens before it — it cannot be allowed to look ahead at words it hasn’t produced yet. So during training and generation, the upper-right half of the grid (where a token would attend to later tokens) is blocked — forced to zero before softmax. This is causal masking.

The attention pattern says how much to listen. Value vectors are what actually gets heard.

Once each token has its attention weights — how much to listen to every other token — the model produces the update in the obvious way: it takes a weighted sum of the value vectors. Tokens you’re attending to strongly contribute most of their value; tokens you’re ignoring contribute almost nothing. That weighted sum is then added back into the token’s vector, nudging its meaning in the direction the context demands.

Notice what this buys us. Before attention, “tower” held a generic tower-vector. After attention in the phrase “Eiffel Tower,” it has absorbed value information from “Eiffel” and now points toward that specific landmark in Paris. The vector literally moved through the space toward a more precise meaning — carrying exactly the contextual information needed to predict what might come next.

One attention pattern captures one kind of relationship. Real sentences have many kinds at once — so the model runs many patterns in parallel.

Everything so far describes a single attention head: one set of Q/K/V matrices producing one pattern. But language is layered — in a single sentence you might simultaneously need to track which adjectives modify which nouns, what each pronoun refers to, and how the verb relates to its subject. No single pattern can do all of that.

The solution is multi-head attention: run many independent heads side by side, each with its own learned Q/K/V matrices, so each head can specialise in a different type of relationship. Their results are then combined. One head might learn to track grammatical subjects, another to link pronouns to their referents, another to attend to the immediately previous word — all at the same time.

Self-attention vs. cross-attention

When all the queries, keys and values come from the same sequence — words within one piece of text attending to each other — it’s called self-attention, and that’s what powers GPT-style models. There’s also cross-attention, where one sequence attends to a different one — for example, a translation attending to the original sentence. We’ll see cross-attention in the encoder–decoder design next module.

You understand the mechanism at the centre of modern AI.

In 2017, a single paper reshaped the field. Let’s read its architecture the way its authors drew it.

The paper Attention Is All You Need introduced the Transformer for a very practical task: machine translation. Its original design has two halves working together — an encoder and a decoder.

Why does this matter for GPT, which we called decoder-only? Because modern generative models essentially kept the decoder — the part that generates text left to right with masked self-attention — and dropped the separate encoder, since pure text continuation doesn’t need a distinct sentence to translate from. The attention machinery, though, is exactly the one you mastered in Module 6.

Attention has a curious blind spot: by itself, it has no sense of order. Positional encoding fixes that.

Recall the Transformer’s great strength — it processes all tokens in parallel rather than one after another. But that creates a problem: if every token is handled simultaneously and attention just compares vectors, then “dog bites man” and “man bites dog” would look identical to the mechanism. Same set of words; only the order differs — and order changes everything.

The original paper used a clever pattern of sine and cosine waves of different frequencies to generate these position vectors. The details matter less than the purpose: it gives every position a distinct, consistent signature the model can learn to read, and it generalises smoothly across distances.

Here is the single equation at the heart of every Transformer. You already understand each piece — now we assemble them formally.

The attention operation from the paper is written compactly as:

Read left to right, it is just the Module 6 story in symbols:

Step through it on a tiny three-token example. Each stage of the formula is computed live so you can watch the grid of scores become weights, then become the output.

Attention is the star, but a Transformer block has a few essential supporting parts that make deep stacking actually work.

A complete block wraps attention with three more ingredients, each solving a practical problem:

• Residual (“add”) connections. The output of attention is added to its input rather than replacing it — the “adjust, don’t overwrite” idea from Module 6. This gives information a clear path through many layers without being lost, which is what makes very deep networks trainable.
• Layer normalisation (“norm”). After adding, the values are re-scaled to a stable, consistent range. Without it, numbers drift to extremes across dozens of layers and training falls apart.
• Feed-forward network. A small two-layer network applied to each position independently — the model’s extra capacity to store and transform learned patterns. Much of its factual knowledge is believed to live here.

The same Transformer behaves quite differently when it is learning versus when it is answering you. The difference explains both its speed and its limits.

During training, the model sees real sentences and, thanks to causal masking, practises predicting every next-token at once — an enormous efficiency win that suits GPUs perfectly. During inference, it must generate left to right: predict a token, append it, feed the longer sequence back, predict the next. This is why long responses stream out over time.

You can now read the original architecture and its core equation.

The most important limitation to understand — because it never fully goes away, but it can be managed.

A hallucination is when a model states something false with total confidence. You can now see exactly why it happens. The objective is plausible next token, and a smooth, confident-sounding fabrication is often more “plausible” as text than an awkward admission of ignorance. Add that training is a lossy compression of the data (Module 4) — details get blurred — and confident errors are almost baked in.

The good news: a stack of techniques meaningfully reduces hallucination.

• Teaching “I don’t know.” As in Module 4, deliberately training on examples where the right answer admits uncertainty helps the model decline rather than invent.
• Retrieval (RAG). Give the model real, relevant documents in the prompt (Module 3) so it answers from sources rather than blurry memory — and can cite them.
• Tool use. Let it call a calculator, database, or search engine for facts it shouldn’t guess at (next lesson).
• Verification on your end. Treat confident claims about specifics — numbers, names, citations — as things to check, not trust.

A subtle, powerful idea that explains both why “show your working” helps and how the new reasoning models were born.

Here is something counter-intuitive: a model can only do a limited amount of computation while producing a single token. Hard problems need more steps than fit in one token’s worth of processing. So when you force a model to jump straight to a final answer, you are denying it room to think.

The fix is to let it spread its reasoning across many tokens. Asking a model to “think step by step” — to write out intermediate reasoning before the answer — genuinely improves accuracy on hard problems, because each generated token becomes a scratchpad the model can build on. This is chain-of-thought.

This insight gave rise to reasoning models. Instead of only imitating human-written text, these are further trained with reinforcement learning to produce long, useful chains of reasoning — trying many approaches and being rewarded for ones that reach correct answers.

A model that can call tools stops being a lonely text predictor and becomes the reasoning core of a larger system.

On its own, an LLM can’t reliably do arithmetic, look up today’s news, or run code — tasks that demand precision or fresh information. The solution is tool use: train the model to recognise when it should hand off to an external tool, emit a request, and incorporate the result. Common tools include:

• a calculator or code interpreter for exact computation,
• web search and retrieval for current or private facts (RAG),
• APIs to take real actions — sending an email, querying a database, booking something.

Four ideas pushing models to be more capable, efficient and general — the vocabulary you need to follow the field.

Mixture-of-Experts (MoE)

Instead of running every parameter for every token, a mixture-of-experts model contains many specialised sub-networks (“experts”) and a router that activates only a few per token. This lets a model hold a huge total parameter count — and the knowledge that comes with it — while only paying to run a small slice each time. More capacity, less compute per token.

Multimodality

The embedding idea generalises beyond text. Multimodal models encode images, audio, or video into the same kind of vector space as words, so a single model can “see” a picture and discuss it, or transcribe and reason about speech. The attention mechanism doesn’t care whether a vector came from a word or an image patch — it relates them all the same way.

Context windows

Recall that context length is the model’s working memory (Module 5). A major frontier is making it far larger — from a couple of thousand tokens to hundreds of thousands or more — so a model can take in whole books, codebases, or long conversations at once. Bigger context means less need to chop information up, though it costs more compute.

Knowledge distillation

Distillation trains a small “student” model to imitate a large “teacher” model. The student ends up far cheaper and faster to run while keeping much of the teacher’s ability — which is how capable models get squeezed onto phones and laptops.

Because LLMs follow instructions written in plain language, they introduce genuinely new security risks. Three are essential to know.

Jailbreaks

A jailbreak is a cleverly worded prompt designed to slip past a model’s safety training — wrapping a disallowed request inside a role-play, a hypothetical, or an unusual format until the model complies. Because the model is fundamentally a flexible text-continuer, no fixed set of rules blocks every creative rephrasing, which makes this an ongoing cat-and-mouse problem.

Prompt injection

Prompt injection is subtler and arguably more dangerous. When a model reads external content — a web page, a document, an email — an attacker can hide instructions inside that content. The model, unable to tell “data it should summarise” from “commands it should obey,” may follow the hidden instructions. This is exactly why a tool-using model that browses or reads files needs careful guarding: malicious text it ingests can hijack its behaviour.

Data poisoning

Data poisoning attacks the training stage. If an adversary can sneak crafted examples into the data a model learns from, they can plant biases or hidden “triggers” that make the model misbehave under specific conditions — a backdoor baked in before the model ever ships.

The final and most human part of the course: the societal questions these systems raise, and one myth to put to rest.

Powerful as they are, LLMs come with real concerns that anyone building or deploying them must weigh:

• Bias. A model trained on human text absorbs human prejudices. Left unchecked, it can reproduce or amplify stereotypes — which is why careful data curation, evaluation, and the alignment work from Module 4 matter so much.
• Copyright & consent. Models are trained on vast amounts of text and images whose creators didn’t necessarily agree to that use, raising unresolved legal and ethical questions about ownership and fair compensation.
• Jobs & disruption. Automating language tasks reshapes work. The honest framing is augmentation and transition, not a simple story of pure benefit or pure harm.
• Misinformation. The same fluency that makes models useful makes them effective at producing convincing falsehoods at scale — a societal risk, not just an individual one.

You can now reason about what LLMs can and can’t do, and the risks they carry.

Twelve questions spanning the whole journey — from the stochastic parrot to the attention equation. No time limit; aim to reason it through.

Every important term from the course, in one place. Skim it to confirm nothing feels unfamiliar.

This course distilled ten excellent talks, arranged from gentle introductions to deep technical dives. Go to the originals to hear these ideas from the people who explain them best.

Start here — intuition

• LLM Explained / What is an LLM — the Buddy-the-parrot intuition for prediction and RLHF. youtube.com/watch?v=67_aMPDk2zw
• What are Large Language Models? (Google) — autocomplete, prompting, zero/few-shot. youtube.com/watch?v=iR2O2GPbB0E
• A Simple Introduction to LLMs — the broad tour: history, tokenization, embeddings, RAG, ethics. youtube.com/watch?v=osKyvYJ3PRM

Build the mental model

• How Large Language Models Work (IBM) — data + architecture + training, business uses. youtube.com/watch?v=5sLYAQS9sWQ
• Large Language Models Explained Briefly (3Blue1Brown) — parameters, pre-training, RLHF, the scale of compute. youtube.com/watch?v=LPZh9BOjkQs
• [1hr Talk] Intro to Large Language Models (Andrej Karpathy) — the two-files model, scaling, tool use, the LLM OS, security. youtube.com/watch?v=zjkBMFhNj_g

Go deep on the Transformer

• But What Is a GPT? (3Blue1Brown, ch.5) — the full data flow, embeddings, unembedding, softmax, temperature. youtube.com/watch?v=wjZofJX0v4M
• Visualizing Attention (3Blue1Brown, ch.6) — queries, keys, values, masking, multi-head attention. youtube.com/watch?v=eMlx5fFNoYc

Expert level

• Deep Dive into LLMs like ChatGPT (Andrej Karpathy) — tokenization, base vs. SFT models, hallucination, tokens-to-think, RL. youtube.com/watch?v=7xTGNNLPyMI
• Attention Is All You Need, explained (Umar Jamil) — the original paper: encoder/decoder, positional encoding, the full math. youtube.com/watch?v=bCz4OMemCcA