Skip to content
Linear Horizon Training

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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

Contact