The curriculum
Read in order if you can. Foundations comes first for a reason: almost every prompting rule that sounds arbitrary turns out to be a direct consequence of how these models generate text.
Every lesson title and summary below is public. Opening a lesson needs a free account.
Foundations
What a language model actually is, how it was trained, and why prompting works at all. Start here even if you have been prompting for months.
- What a language model actually isTokens, embeddings, and next-token prediction. Everything else in this course is a consequence of these three ideas.7 min
- Neural networks and the transformerWhat attention actually computes, why it displaced recurrent networks in about two years, and what a context window means when you are the one filling it.7 min
- How models are trainedPretraining, instruction tuning, and reinforcement learning from feedback. Where a model's helpfulness comes from, and why that shapes what your prompts can ask of it.7 min
- Inference mechanicsTemperature, top-p, and what reasoning models do differently. The settings around your prompt change the output as much as the prompt does.7 min
- A history of AI, told properlySeventy-five years from Turing's question to the frontier labs, as a story about a single idea being abandoned and revived twice.8 min
- The people who got us hereNine short profiles, each tied to the specific contribution that still shows up in the model you used this morning.7 min
- The kinds of models in use todayLanguage, multimodal, diffusion, speech, embedding, and agentic models. What each is for, and why prompting them well means different things.7 min
- Why prompting works at allIn-context learning is the reason this whole discipline exists. Here is what the model is doing when your examples change its behaviour without changing its weights.6 min
- Where the training data comes fromA model is a compressed statistical summary of a corpus. What is in that corpus, what was filtered out, and why both show up in your output.6 min
- Probability, gentlyThe small amount of probability you need to understand every other lesson - distributions, sampling, and why the same prompt gives different answers.6 min
- The hardware underneathWhy GPUs made this possible, what actually happens when you send a prompt, and why hardware constraints explain context limits, latency and cost.6 min
- Prompting, retrieval, fine-tuningThe three ways to change what a model does, what each can and cannot fix, and the decision that saves the most wasted effort in this whole field.6 min
Beginner
The anatomy of a prompt that works, the mistakes that quietly ruin most of them, and the habit of treating a prompt as a draft.
- What a prompt is, and what it isn'tA prompt is not a search query and not a conversation with a colleague. Getting the mental model right removes most beginner problems before they start.5 min
- Anatomy of a prompt that worksInstruction, context, input data, output format. Four parts, each removing a different class of failure, usable as a checklist on anything you write.6 min
- The mistakes almost everyone makesSeven failure patterns, each traced back to the mechanism that causes it, so you can recognise them in your own prompts rather than memorising a list.6 min
- Zero-shot, one-shot, few-shotShowing beats describing, but only if your examples are built correctly. When to use examples, how many, and the mistakes that make them backfire.6 min
- Treating a prompt like a first draftThe habit that separates people who occasionally get good output from people who get it reliably. Iterate on the prompt, not on the output.7 min
- Reading model output criticallyA practical checking routine. Which parts of an answer are most likely wrong, how to spot invention, and what to verify before you rely on anything.6 min
- When not to use a model at allThe skill nobody teaches. Tasks where a model is the wrong tool, and recognising them before you have spent twenty minutes finding out.6 min
- Your first prompt libraryClosing the Beginner track. Turning the prompts that worked into something you keep, and the small discipline that makes them get better over time.6 min
Intermediate
Roles, system messages, delimiters, chain-of-thought, structured output, and a checklist for debugging a prompt that will not behave.
- Role and persona promptingAssigning a role shifts register, vocabulary and priorities. It does not grant expertise the model lacks - and on knowledge-heavy tasks it measurably hurts.7 min
- System messages versus user messagesThe message roles are not interchangeable, and they are not separate channels either. What belongs where, and why system instructions decay over a long conversation.7 min
- Delimiters and XML-tag structuringAn unmarked boundary between your instruction and your data is a real ambiguity, not a stylistic one. Why tags outperform prose, and why Claude in particular rewards them.6 min
- Chain-of-thought and giving the model room to workWhy writing intermediate steps improves accuracy, how to elicit reasoning deliberately, and why the technique is now largely redundant on reasoning models.7 min
- Structured output and why it matters downstreamGetting JSON that parses every time. Why "mostly valid" is the worst failure mode there is, and why constrained decoding beats asking nicely.7 min
- Context engineering basicsDeciding what goes in the window and what stays out. Relevance density beats volume, and a large context window is not an argument for filling it.6 min
- A systematic checklist for a prompt that will not behaveAn ordered diagnostic procedure. Most prompt debugging fails because people rewrite before identifying which kind of failure they have.7 min
Advanced
Tree-of-thought, self-consistency, verification chains, meta-prompting, agent and tool-use prompting, injection defence, and token economics.
- Tree-of-thoughtExploring several reasoning branches and evaluating between them, instead of committing to whatever the first step happened to be.7 min
- Self-consistencySample the same prompt several times and take the majority answer. A statistical fix for a statistical process, and the rare technique with no prompt craft in it at all.6 min
- Self-refine and chain-of-verificationHaving a model critique and correct its own work, and the specific conditions under which that helps rather than launders the error.6 min
- Meta-promptingUsing a model to write, critique and optimise prompts - including the one you are stuck on. Powerful, and it inherits every bias of the model doing the optimising.7 min
- Multi-step prompt chainsDecomposing a task across several calls, where each step does one thing well and hands a clean artefact to the next. Also how a weak early step quietly poisons everything after it.6 min
- Agent and tool-use promptingPrompting shifts from crafting one instruction to specifying goals, writing tool contracts, and deciding when the loop is allowed to stop.7 min
- Prompt injection and defensive promptingWhen untrusted text enters the context it can carry instructions. Why this is structural rather than a bug, and what genuinely reduces the risk.7 min
- Evaluating prompts systematicallyMoving from "this looks better" to a measurement you can defend - using this site's own eight-dimension rating rubric as the worked example.7 min
- Token economicsWhat your prompts actually cost, where the money goes in a production system, and which optimisations are worth doing.7 min
Model Playbooks
What actually changes between Claude, GPT, Gemini, open-weight models, and image models - and how to decide which one a task belongs to.
- ClaudeXML structuring, long-context placement, and extended thinking. What Claude rewards that other families are indifferent to - and one widely-taught technique that now errors.7 min
- GPT and ChatGPTMessage roles, function calling, schema-constrained output, and explicit controls for reasoning effort and verbosity that most prompts leave at default.6 min
- GeminiNative multimodality, search grounding, and context measured in millions of tokens. Prompting a model built to take images, audio and video as first-class input.6 min
- Open-weight modelsLlama, Mistral, DeepSeek and Qwen. Chat templates, quantisation, and why techniques tuned on frontier models quietly stop working here.6 min
- Image generation modelsMidjourney, Stable Diffusion and GPT-Image speak a visual-descriptor language, not prose. Genuinely the most different discipline in this course.7 min
- Which model for which taskThe closing decision matrix. Matching a task to the smallest model that clears the bar, and recognising the constraints that override capability entirely.7 min
For Students
Using these tools for coursework without outsourcing the thinking. Studying, researching, checking your own work, and staying on the right side of academic integrity. Readable straight after Beginner.
- Using AI without outsourcing your thinkingThe distinction that decides whether these tools make you better or hollow you out - and it is not about how much you use them.6 min
- Prompting for understanding, not answersConcrete prompts that build comprehension instead of replacing it - explain-back, worked examples, deliberate wrongness, and the question that exposes a gap fastest.7 min
- Research and citations without fabricationModels invent citations that look perfect. Why it happens, how to make it visible, and a workflow that gets you real sources instead of plausible ones.6 min
- Getting real feedback on your own workModels are trained to be encouraging, which makes them poor critics by default. How to get a critique that is actually about your work.6 min
- Studying and revision that actually worksTurning a model into a practice-testing machine. Spaced retrieval, generated questions, and the difference between revising and re-reading.6 min
- Academic integrity, honestlyWhere the line actually is, why detection tools cannot find it, and how to use these tools in a way you could explain to your examiner without discomfort.7 min
- Building a system that outlasts the modelClosing the student track. A small set of saved prompts, an error log, and habits that survive the tools changing under you - because they will.6 min
At Work
Job-shaped playbooks: writing, code you have to maintain, analysis, research, and getting a team to prompt consistently. For the practitioner who arrived with a task rather than a syllabus.
- Writing you have to put your name onDrafting, editing and rewriting at work, where the output goes out under your name and generic prose is a professional cost rather than an aesthetic one.6 min
- Code you have to maintainGenerating code is easy. Generating code you will still understand in six months, that fits the codebase it lands in, is a different prompt.6 min
- Data and analysisWhere models are least trustworthy and most confidently wrong. How to get analytical help without importing invented numbers into a decision.6 min
- Research and briefingsGetting up to speed on an unfamiliar area fast, without mistaking a confident summary for knowledge - and knowing which parts you still have to verify yourself.6 min
- Getting a team to prompt consistentlyClosing the track. Shared prompts, a review habit, and the small amount of process that stops everyone solving the same problem separately and differently.6 min
Cost of a Prompt
What a prompt actually costs in energy, money and time - and why writing one good prompt instead of five vague ones is the most direct thing any individual can do about it.
- What one prompt actually costsReal measured numbers, including the ones that turned out to be wrong. A single query is smaller than you have been told - and that is not the end of the argument.6 min
- The iteration multiplierThe central argument of this track. A vague prompt is not one request - it is the first of several, and the multiplication is where the waste actually lives.7 min
- Right-sizing the modelThe largest lever any individual actually controls. Using a reasoning model for a task that needed a small one is the most common form of waste there is.6 min
- Where the energy actually goesTraining versus inference, data centres and grids, and the water question. The systems-level picture, so you can tell a real concern from a viral one.6 min
- The engineering of restraintIf you build something that calls a model, you control the levers that actually matter. Caching, routing, batching, and knowing when not to call at all.6 min
- What you can and cannot changeThe closing lesson of this track. An honest accounting of leverage, so you spend your effort where it does something and stop feeling guilty where it does not.6 min