Applied LLMs — Origins to Production

Large language models, taught in the order you'd actually learn them. The historical arc first, because it explains why the architecture looks the way it does. Then the mechanics of attention. Then the three things you'll actually build with — retrieval, prompting, and a deployment target. Then two applied case studies where the theory meets a messy domain.

Who this is for

You can write Python and you've used ChatGPT, but you couldn't currently explain what a token is, why context windows have limits, or why your RAG prototype returns confidently wrong answers. By the end you'll be able to reason about all three from first principles rather than from folklore.

No maths prerequisite for parts 1–2. Part 7 (CS229) is the optional on-ramp if you want the statistical-learning foundation underneath.

---

The path

Part 1 · Foundations (~18 min, beginner)

Where LLMs Came From, and What They Actually Are

The 80-year chain where each step exists because the previous one hit a wall, then the five ideas that genuinely matter. No maths. The load-bearing takeaway: an LLM predicts the next chunk of text, and everything else — chat, reasoning, refusals — is a consequence of doing that one thing at enormous scale and then shaping the result.

Start here even if you think you know this. The rest of the series assumes this mental model.

Part 2 · Mechanics (~8 min, intermediate)

How Transformers Actually Attend

The inside of the machine. What queries, keys and values are doing, why self-attention scales quadratically with sequence length, and why that single fact drives almost every architectural decision downstream — context limits, cost curves, and the entire FlashAttention line of work.

Prerequisite: part 1. This is the only part where the maths shows up.

Part 3 · Retrieval (~12 min, intermediate)

RAG Architecture Basics and Workings

Chunking, embeddings, vector search, reranking, and the assembly of a grounded prompt. Also where RAG quietly fails: chunk boundaries that split the answer in half, embeddings that retrieve topically-similar-but-wrong passages, and the retrieval step silently returning nothing.

Prerequisite: part 1. Part 2 helps but isn't required.

Part 4 · Prompting (~3 min, beginner)

Best LLM Prompt for Understanding Any Concept In-Depth

A short, practical one. A reusable prompt structure for driving a model into genuine depth on a topic instead of getting a Wikipedia summary back. Useful immediately, and a concrete demonstration of why prompt structure changes output quality.

Part 5 · Applied — audio (~9 min, intermediate)

Automating Audio Generation

The first case study. Text-to-speech pipelines end to end: the API surface, batching, and the practical problems (pronunciation, pacing, cost per minute) that only show up once you generate more than a demo.

Part 6 · Applied — clinical NLP (~8 min, intermediate)

Medical Error Detection and Correction in Clinical Notes

The second case study, and deliberately a hard domain. What happens when the cost of a confident wrong answer is high, why generic benchmarks mislead you here, and how error detection differs from error correction as a task.

Part 7 · Foundations, optional (~6 min, beginner)

Stanford CS229: Machine Learning

The classical-ML grounding underneath everything above. Optional and out of sequence on purpose — read it when you want to know why gradient descent, regularisation and bias/variance keep coming up, not before.

Part 8 · Shipping (~10 min, intermediate)

Basics of Azure AI Foundry

Where a prototype becomes a deployed thing: model catalogue, deployments, evaluation, and the operational surface you inherit the moment something is in front of users.

---

How to read this series

Start at part 1 and move forward. Every post has prev/next navigation at the bottom, so you can walk the whole track without coming back here.

If you only have an hour: parts 1, 3 and 8 give you the shortest path from "what is this" to "I deployed something".

What this series does not cover

Being explicit about the edges, so you know when to look elsewhere:

• Training or fine-tuning from scratch — that's the DL & LLMs from Scratch series, 80 sessions of it.
• Agent frameworks and tool use — deliberately out of scope; the ground moves too fast for evergreen writing.
• Evaluation methodology in depth — touched on in part 8, not treated properly.

Open the full series →