How does a language model get from a pile of numbers to something that can answer a question? Anthropic researcher Jeremy Berman walks Matthew Berman through that question in a nearly hour-long interview. He begins with a tiny apartment-price model, then scales the intuition up to language modeling, assistant training and reinforcement learning. The result is a rare explanation that starts with the actual optimization loop rather than a list of AI buzzwords.
Training adjusts a model's numerical parameters to reduce an objective measured on examples. In language-model pre-training, that objective commonly involves predicting the next token. Further training can teach the model to follow instructions and favor better responses, including on tasks where outcomes can be checked. Each stage changes behavior; none by itself makes the model a reliable source of truth.
Watch the Interview
Jeremy explicitly frames the conversation as a high-level, intuitive tour, not a disclosure of Anthropic's private model-development recipe. The sections below follow his sequence while using public papers and model documentation to qualify the shortcuts that make the explanation approachable.
Start With the Knobs: Weights, Loss and Gradients
Jeremy's first model predicts New York apartment prices from features such as size, bathrooms and location. Imagine a function with adjustable numerical weights. Change the weights and the predicted price changes. Compare that prediction with the known sale price, summarize the error as a loss, and adjust the weights toward a lower loss. He calls the weights "knobs" to make the mechanism visible. Watch the apartment example.
Real training does not involve a person turning millions of knobs by hand. Jeremy demonstrates a small Python/PyTorch example in which automatic differentiation computes how a change in each parameter affects the loss. An optimizer uses those gradients to update the parameters, over many examples and steps. PyTorch's autograd documentation explains the computational graph and reverse-mode differentiation behind this step. A lower training loss is a useful signal, but whether the model works on new data must be evaluated separately. Watch the training walkthrough.
The Training Pipeline at a Glance
| Stage | What changes | What it does not prove |
|---|---|---|
| Prepare data and tokens | Text is converted into token IDs; examples are organized for training. | More data is not automatically cleaner, lawful or representative. |
| Pre-train | Update parameters to predict tokens across many examples. | Fluent continuation is not the same as truth or following instructions. |
| Supervised post-train | Learn from examples of desired answers and conversation format. | Imitating demonstrations does not cover every new situation. |
| Preference or outcome training | Favor responses that score better under human feedback or checkable rewards. | A reward can be incomplete or gamed; results still need independent tests. |
| Evaluate and deploy | Test capabilities and failure modes, then serve the model with safeguards. | Benchmarks and safeguards cannot eliminate all errors. |
This is an explanatory map, not a universal recipe. Different systems combine, repeat or skip stages; model architecture, data curation, compute and evaluation matter too. The Transformer paper is a foundation for many modern language models, but it is not itself a complete production training manual.
Pre-training: Learn to Continue a Sequence
For the language-model example, the model sees a sequence of tokens and is trained to assign higher probability to the actual next token. Tokens can be words, parts of words or punctuation, depending on the tokenizer. Repeating that task at scale teaches a model statistical structure in language, code and other training data. Jeremy shows why a base model may simply continue the apparent pattern in a prompt instead of behaving like a helpful chat assistant. Watch his base-model comparison.
The comparison is tangible in Qwen's published Qwen2.5-0.5B base and Qwen2.5-0.5B-Instruct model cards. They are related models with different intended interaction patterns; the instruct card shows a chat template with role-formatted messages. The cards make a useful follow-along reference, though they do not tell us the private training recipe for Claude.
Post-training: Make a Model Useful in Conversation
Jeremy's next distinction is between learning to continue text and learning to respond to a person. In supervised fine-tuning, examples can show the model what a useful answer looks like, how to respect message roles and when to stop. Feedback can then push it toward answers people prefer. The foundational InstructGPT paper describes one public pipeline: fine-tune on human demonstrations, collect rankings of model outputs, then use reinforcement learning from human feedback. That is an example of a method, not a claim that every modern model uses the identical sequence. Watch Jeremy explain the distinction.
Post-training can make a model more responsive to instructions. It does not magically insert a verified database of facts. An assistant can follow the requested format, sound confident and still be wrong. That is why factual checks, held-out evaluations and real-world testing remain part of the job.
Intermediate Steps and Reinforcement Learning
Jeremy then turns to problems that benefit from working through intermediate steps. Chain-of-thought prompting asks a model to produce or use a step-by-step path before an answer; the original chain-of-thought paper showed gains on some complex reasoning tasks. Visible steps are useful for inspection, but they are not a certificate that the answer is correct or that the displayed text faithfully describes every internal computation. Watch the chain-of-thought section.
For tasks with checkable outcomes, a training system can generate several candidate solutions, score them and update the model to favor better-performing behavior. Jeremy uses DeepSeek-R1 to explain this intuition. Its paper describes reinforcement learning for reasoning, including Group Relative Policy Optimization (GRPO), which compares sampled responses within a group. The practical constraint is the reward: a verifier can be powerful for a math answer or a testable coding task, but a narrow score can miss usefulness, safety or real-world correctness. Watch the reinforcement-learning section.
What the Simple Story Leaves Out
- Weights are not the whole product. The trained numbers matter, but so do architecture, tokenizer, training data, optimization, inference software and the surrounding interface.
- Loss is not understanding. A model can reduce its objective and still fail on unfamiliar, ambiguous or adversarial inputs. Evaluate generalization, not just training performance.
- Fluency is not truth. Next-token training rewards plausible continuation. Post-training changes behavior but does not make every statement source-checked.
- Reward is not the real world. Reinforcement learning improves what is measured. Weak or incomplete rewards can encourage behavior that looks successful to the scorer while missing the user's goal.
- Future discovery is a forecast. Jeremy closes by discussing the possibility of models making novel discoveries. Treat that as an informed outlook, not evidence that every current model is an autonomous scientist. Watch the closing discussion.
A Good Route for Learning the Mechanics
- Understand one tiny optimization loop. Replay Jeremy's apartment example, then read PyTorch's autograd note. Be able to explain prediction, loss, gradient and update in one sentence each.
- Compare a base and instruct model. Read the two Qwen model cards. Look for the intended input format and training difference, rather than judging capability from one chat response.
- Read one paper per stage. Use InstructGPT for instruction and preference training, the chain-of-thought paper for prompted intermediate steps, and DeepSeek-R1 for outcome-based reasoning training.
- Keep asking what is measured. For every claimed improvement, identify the training signal, the held-out test and the task where a human would notice failure.
Video Chapters
| Time | Topic |
|---|---|
| 00:00 | Introduction and the seven-part roadmap |
| 02:15 | Neural network fundamentals |
| 11:42 | The training process |
| 24:57 | Large language models overview |
| 35:34 | Pre-training versus post-training |
| 42:27 | Chain of thought |
| 45:06 | Reinforcement learning and reasoning |
| 53:38 | Future discovery and closing |
Sources and Scope
- Primary interview: Matthew Berman with Jeremy Berman; article prepared from the user-supplied transcript. Follow Jeremy at @jeremyberman.
- Training mechanics: PyTorch autograd and Attention Is All You Need.
- Post-training and reasoning: InstructGPT, chain-of-thought prompting and DeepSeek-R1.
Scope note: These public sources support the general methods discussed. They do not independently verify Anthropic's private training data, internal model design or Jeremy's forecast about future discoveries. Sources checked 14 November 2026.