Watching guide

Deep Dive into LLMs like ChatGPT

This page is meant to sit in a second tab beside the original — it explains and orients, but it is deliberately useless as a substitute. Sections are keyed to timestamps.

Open the video ↗

Before you watch

Treat this as a course with four class sessions, not a video to finish in an evening. It runs three and a half hours and builds strictly in order. Watching it straight through is possible and mostly wasteful: the payoff segments sit on the far side of technical stretches you may skim.

The one-hour talk is the prerequisite. Watch Intro to Large Language Models first; it gives you the shape of the thing — a giant file of numbers, trained by prediction, then turned into an assistant — in one sitting. This lecture assumes that shape and fills it in. Starting here instead is the most common way people bounce off it.

Four sittings, each ending where Karpathy himself stops to summarize:

  1. 0:00–1:00:00 — Pretraining. Data, tokens, training, inference, and what a raw "base model" is.
  2. 1:00:00–2:09:48 — Post-training and psychology. How a text completer becomes an assistant, and the failure modes that result.
  3. 2:09:48–3:06:57 — Reinforcement learning. Practice problems, reasoning models, human feedback.
  4. 3:06:57–end — The payoff. What it means for using these tools, and where the field is heading. Join it to sitting three if you have the stamina.

A non-technical viewer can skim roughly 19:55 to 46:55 — network internals, the live training run, GPU economics. Nothing later depends on the details. No one should miss hallucinations and tools (1:20–1:39), tokens to think (1:46–2:07), the reinforcement-learning arc (2:11–3:06), and the closing advice (3:08–end).

One caveat throughout: recorded February 2025, days after DeepSeek R1's release. The framework has held up; several specific claims have not.

While you watch

0:56 — Downloading the internet: what training data actually is

"even though the internet is very very large we're working with text and we're also filtering it aggressively"

The lecture opens on a public dataset (FineWeb) rather than a diagram: before anything else, a model is a pile of filtered web pages. Watch the stages — blocklists, HTML stripped to prose, non-English dropped, duplicates and personal information removed. Pause on the number 44 terabytes: the readable internet, strained hard, fits on one drive. Every judgment there becomes a property of the model.

Open this moment in the video →
7:45 — Tokens: the alphabet a model actually reads

"I really encourage you to think of these not as numbers but as unique IDs"

Text must become a sequence of symbols from a fixed vocabulary. Karpathy walks from bits to bytes to "byte pair encoding," which merges common pairs until the vocabulary holds about 100,000 chunks. Follow the live demo where "hello world" splits differently by capitalization and spacing. The highest-leverage stretch of the first hour: it silently explains the failures two hours later. The model never sees letters. It sees chunk IDs.

Open this moment in the video →
14:58 — Inside the network: prediction, parameters, and a very expensive coin flip

"think of these parameters as kind of like knobs on a DJ set"

The deep end; Karpathy says himself the mathematics is not the important part. Hold onto this: the network takes a window of tokens, outputs a probability for every possible next token, and gets nudged so the true one grows likelier — billions of times over. Generation reverses it: sample, append, repeat, which is why one prompt gives different answers. Skim the rest.

Open this moment in the video →
46:55 — The base model: an internet simulator you can talk to

"a glorified autocomplete it's a very very expensive autocomplete of what comes next"

The most memorable half hour of sitting one. Karpathy opens a raw pretrained model and shows it is not an assistant at all: it wanders, it invents. Then three revealing tricks. It recites a Wikipedia article from memory. Asked about an election past its training cutoff, it generates two confident parallel universes. Given ten example translations, it infers the pattern and continues it — learning inside the prompt.

Open this moment in the video →
1:00:31 — Post-training: how the assistant gets installed

"you're not talking to a magical AI you're talking to an average labeler"

Same algorithm, different data. The internet is thrown out and replaced with a curated set of conversations, most now drafted with model help but originating in human writing. Notice how humble the machinery is: hired labelers working from written instructions about being helpful, truthful, and harmless. The persona you talk to is a statistical average of those people following those instructions. This deflation is the lecture's emotional center; sit with it.

Open this moment in the video →
1:20:27 — Hallucinations, tools, and the two kinds of memory

"the model basically doesn't know and it's just imitating the format of the answer"

Do not skim this. Hallucination is explained not as a bug but as an inevitability: the training data is full of confidently answered questions, so the model learned that the form of an answer is confidence. Two fixes follow — find the edge of what it knows and teach it to say so, then give it a search tool. That yields the lecture's central rule: knowledge in the weights is vague recollection, text in the context window is working memory. Paste in the chapter you want summarized rather than trusting recall.

Open this moment in the video →
1:46:54 — Why models need tokens to think

"these are not for you these are for the model"

The most useful twelve minutes in the video. Each token gets a small, roughly fixed amount of computation, so a model asked to answer immediately must cram the whole problem into one step — and past a certain difficulty it fails. Karpathy proves it live by forbidding intermediate steps and watching a word problem break. Anything after the answer is retroactive rationalization; the answer is already locked in. This is why step-by-step prompting works: architecture, not style.

Open this moment in the video →
1:58:21 — Counting, spelling, and 9.11 versus 9.9

"the models don't see characters they see tokens"

The famous embarrassments, now explained. Counting dots fails because counting demands more computation than one token allows. Spelling fails because letters are welded inside chunks the model cannot look into — the strawberry problem, and the payoff for that tokenization segment ninety minutes earlier. Then a genuine mystery: 9.11 judged larger than 9.9, apparently because neurons associated with Bible verses light up. He cannot fully explain it — the honest note the segment needs.

Open this moment in the video →
2:11:13 — School: exposition, worked solutions, and practice problems

"we really want the llm to discover the token sequences that work for it"

The analogy organizing the last third. A textbook contains exposition (pretraining), worked solutions from an expert (supervised fine-tuning), and practice problems with only an answer key (reinforcement learning). The argument for that third stage is worth pausing on: a labeler writing an ideal solution cannot know which path is easy for the model, whose cognition is not ours. So let it try thousands of solutions and keep what works.

Open this moment in the video →
2:28:52 — DeepSeek R1 and the moment a model learned to second-guess itself

"the model is discovering ways to think it's learning what I like to call cognitive strategies"

The high point of the lecture, filmed days after the paper landed. Accuracy climbs — but so does answer length, because the model spontaneously starts backtracking, re-checking, trying second approaches. Nobody wrote those behaviors in; they emerged from being rewarded for correct answers. Karpathy runs a reasoning model live so you can watch it argue with itself, then closes on AlphaGo's move 37 — a play no human would make — as the shape of going beyond imitation.

Open this moment in the video →
2:50:52 — RLHF: the trick that works and the trap it sets

"we are doing reinforcement learning not with respect to humans and actual human judgment"

For creative tasks there is no answer key, so a second network is trained to imitate human preference rankings and the model optimizes against that. It works, for a good reason: ranking five jokes is far easier than writing one. Then the trap. Run the optimization long enough and it finds nonsense the scorer adores. There is no fix, only a stopping rule — improve for a few hundred steps, then ship. His verdict: fine-tuning wearing reinforcement learning's clothes.

Open this moment in the video →
3:08:19 — Swiss cheese, what's coming, and how to keep up

"the models are incredibly good across so many different disciplines but then fail randomly"

The closing image is the one to keep: capability like Swiss cheese, brilliant almost everywhere and arbitrarily absent in holes you cannot predict. Then the forecast — native audio and images, agents running for hours under supervision, models that keep learning after deployment (nothing today does). Finish with the advice, unglamorous and correct: use these as tools, take the first draft, check the work, own the result.

Open this moment in the video →

Counterpoints

  • Can next-token prediction produce understanding? Karpathy's framing — "token tumbler," a simulation of a labeler — sits on the deflationary side, in company with Bender and Koller's argument that form alone cannot yield meaning. The opposing case: predicting text well enough requires internal models of what it describes, and interpretability work keeps finding them. The lecture arms both readings and settles neither.
  • RLHF's critics go further than he does. He treats reward gaming as a technical ceiling; others as a live harm — optimizing for what raters approve of trains models to flatter. Anthropic's sycophancy research documents it across systems; the wiki's sycophancy entry tracks where it stands now.
  • The frontier has moved. The video states that Anthropic offers no thinking model — untrue within weeks. Reasoning models went from novelty to default and the leaderboard he recommends has been superseded repeatedly. Treat product claims as period detail; the three-stage framework is what stays.

Questions to carry

  • If the assistant simulates a hired labeler, and the training data is now largely written by earlier models, what is the third generation simulating?
  • Reinforcement learning only bites where answers can be checked. Which parts of your own work have an answer key — and does that predict where these models improve fastest?
  • If reward models can always be gamed, does every system trained on human approval carry that flaw, however good it looks now?
  • Reasoning happens in visible tokens. What follows for trust when a company hides them, as he notes they do?

Go deeper

  • RLHF — the technique behind the assistant's manners, and its limits.
  • Reward hacking — the "the the the" failure generalized: why it recurs wherever optimization meets a proxy.
  • DeepSeek R1 — the paper he reads on screen, and what it changed about who can build a reasoning model.
  • Reasoning tokens — how thinking-before-answering is billed, shown, and hidden.
  • Test-time compute — the principle behind "models need tokens to think."
  • Tool use — search and code execution, the standing remedy for hallucination and arithmetic.