Ready-made course · 1 day · Intermediate
How Large Language Models Work
A one-day explanation of LLM internals for developers, architects and technically curious professionals. Enough mechanism to improve engineering decisions, without a research-paper prerequisite.
Many teams are building on large language models without a usable picture of the mechanism. That leads to poor assumptions about memory, truth, context, fine-tuning and cost. This course explains how current models actually work, at a depth that changes how you design systems.
The day covers tokenisation, embeddings, attention, the transformer stack, training, inference and sampling. Pretraining, instruction tuning, alignment and fine-tuning are separated carefully, because they answer different problems. Quantisation, model size and scaling are discussed as engineering constraints rather than as a race.
The explanations are visual and concrete. Small demonstrations show what tokens look like, how sampling changes output, and why a longer context is not the same thing as understanding. Mathematics is used where it clarifies; it is not the point of the course.
You leave able to reason about context windows, latency, model choice and the limits of prompting, retrieval and fine-tuning with more than folklore.
- Who it is for
- Developers, architects, technical product leaders and technically curious professionals who will make or influence engineering decisions about LLMs.
- Before you start
- Comfort with software concepts is expected. No specialist mathematics is required. Programming is helpful for the demonstrations but not mandatory.
You will be able to
- Explain tokenisation, embeddings and next-token prediction in enough detail to reason about prompts and context.
- Describe attention and the transformer block as an engineering architecture, not as a metaphor.
- Compare pretraining, instruction tuning, alignment and fine-tuning, and say which problem each addresses.
- Predict how temperature, sampling, context length and model size affect output, cost and latency.
- Diagnose common misconceptions about memory, truth, citations and “the model knows X”.
- Use a clearer model of inference, quantisation and scaling when choosing between hosted and local models.
- Connect internals to practical choices: prompting, RAG, fine-tuning and evaluation.
Modules
4 quarter-day modules. Each one can go into a custom course on its own.
Tokens, embeddings and next-token prediction
- Tokenisers, vocabularies and why token counts matter.
- Embeddings: meaning as position in a vector space.
- Next-token prediction as the whole of the job.
- Demonstration: inspect tokens and embeddings for real text.
Attention and the transformer
- Attention without the maths first, then with a little of it.
- Layers, heads and what the model builds up inside.
- Context length, and why long contexts cost more.
- Demonstration: visualise attention on a short passage.
How models are trained and aligned
- Pretraining on large corpora: what the model learns and what it does not.
- Instruction tuning and preference training.
- Reasoning models and extra compute at answer time.
- Fine-tuning versus prompting versus retrieval.
Inference, sampling and practical limits
- Temperature, top-p and why the same prompt gives different answers.
- Latency, throughput and what drives cost per request.
- Knowledge cut-offs, hallucination and calibration.
- Demonstration: the same question at different settings.
Practical work
The course uses visual explanations and small demonstrations rather than a full implementation lab. You inspect tokenisation, sampling behaviour, context effects and the difference between base and instruction-tuned models, then apply that picture to design questions from your own systems.
You take away
- A working mental model of tokens, attention, training and inference
- A vocabulary that holds up in architecture discussions
- A short decision map connecting internals to prompting, RAG, fine-tuning and model choice
- Reference notes and diagrams from the day
Combine it with
- Generative AI Fundamentals · 1 day
- Practical Generative AI at Work · 1 day