How LLMs Work
AI Literacy for EMs gives you the manager’s mental model — enough to scope work, smell a bad claim, and lead a team that uses these tools. This page is the step down from there: actually understanding how a large language model works under the hood.
You don’t need this to be a good manager. But the leaders who invest here stop treating the model as magic — they can reason about why it fails, follow their engineers into the details, and make sharper calls on AI-native work. It’s also the single best thing to hand a curious engineer who wants to go deep. Fair warning: the full path below is real study — call it fifteen-plus hours end to end. You don’t have to do all of it. The two intros alone will change how you think about these tools.
Start gentle: two talks to build the intuition
Andrej Karpathy — a founding member of OpenAI and former head of AI at Tesla — is the clearest LLM teacher working today. Watch these two, in order:
- How I use LLMs (~2 hrs) — the practical one. What these tools can actually do, feature by feature, with real examples. Start here; it’s the gentlest on-ramp there is.
- Deep Dive into LLMs like ChatGPT (~3.5 hrs) — the mechanics. How a model is trained, what tokens really are, why it hallucinates, and where its stranger behaviors come from. This is the “aha” one — after it, most AI news stops being mysterious.
If you only ever watch these two, you’ll be ahead of most people talking confidently about AI in meetings.
Go deep: Stanford’s CME 295 course
For the real thing, Stanford’s CME 295 — Transformers & Large Language Models (Autumn 2025, taught by Afshine and Shervine Amidi) is one of the strongest free LLM curricula going. Nine lectures, roughly 1.5–1.75 hours each, building from the transformer up to agents and evaluation. Watch them in sequence — each one leans on the last.
| # | Lecture | What it covers | Runtime |
|---|---|---|---|
| 1 | Transformers | The architecture everything else is built on — attention, walked end to end | 1:42 |
| 2 | Transformer Tricks | The practical techniques and variants that make transformers work at scale | 1:47 |
| 3 | Large Language Models | How a transformer becomes the LLM you actually use | 1:49 |
| 4 | LLM Training | Pretraining, supervised fine-tuning, and LoRA | 1:47 |
| 5 | LLM Tuning | Aligning a model to human preference — RLHF, PPO, DPO | 1:48 |
| 6 | LLM Reasoning | How models learn to reason — RL scaling and GRPO | 1:47 |
| 7 | Agentic LLMs | RAG, tool calling, and agents — models that take actions | 1:49 |
| 8 | LLM Evaluation | How you actually know it works — LLM-as-a-judge and benchmarks | 1:49 |
| 9 | Recap & Current Trends | Tying it together and where the field is heading | ~1:45 |
The full playlist, plus the slides and readings, live on the course site.
How to actually get through it
Watching lectures back to back feels productive and teaches you almost nothing. What works:
- Go in sequence, and don’t rush. Each lecture assumes the last. Spread them out over weeks, not a weekend.
- Take notes in your own words. If you can’t restate a concept plainly, you haven’t got it yet — the same test you’d apply to anything.
- Recreate the simple examples as you go, even just on paper.
- Build one small project every few lectures — a tiny script that calls a model, a toy retrieval over your own notes, a mini eval. The aim is to understand deeply enough to build with it, evaluate it, and explain how it works, and building is what makes it stick.
Where to go next
You’ve got the foundation — now put it to work:
- AI-Assisted Engineering — this understanding, applied in the everyday dev workflow.
- AI-Native Engineering — designing systems with the model at the core, where knowing the failure modes really pays off.
📚 Go Deeper
Books
- The Illustrated Transformer — Jay AlammarThe canonical visual explainer of attention and the transformer. Read it alongside Stanford Lecture 1 and the architecture clicks twice as fast.
- Build a Large Language Model (From Scratch) — Sebastian RaschkaThe hands-on book for the 'build a small project' instinct — code a working LLM end to end, one chapter at a time, in plain PyTorch.
Courses
- Andrej Karpathy on YouTubeThe two intros on this page are his. The rest of the channel — including the famous '[1hr Talk] Intro to Large Language Models' — is the clearest LLM teaching anywhere.
- Stanford CME 295 — course siteThe home of the deep-dive course below: syllabus, slides, exams, and the readings behind every lecture. Skim the slides to preview or review without watching the full 1.75 hours.
- 3Blue1Brown — Neural Networks seriesA visual, math-light picture of what a transformer is doing inside — a gentle warm-up before the Stanford depth, and the best animation of 'attention' out there.
Tools
- Hugging FaceWhere open models and datasets live, plus a free hands-on LLM course — the natural place to actually run the small experiments this page keeps nudging you toward.