Course: Course 3 — LLM Fine-Tuning Masterclass
Module: FT15 — CoT Distillation and Rejection-Sampling FT
Duration: ~45 minutes (spoken at ~140 wpm)
Format: Verbatim transcript with [SLIDE N] cues. Read aloud or use as speaker notes.
[SLIDE 1 — Title]
Welcome to module FT fifteen, CoT Distillation and Rejection-Sampling Fine-Tuning. This is Pillar Four, the reasoning pillar, and it is the direct follow-up to FT fourteen on GRPO. FT fourteen gave you the most powerful tool in the course for getting reasoning into a model — full RL on verifiable rewards. It is also the most expensive and the most unstable thing you will encounter. So the question FT fifteen answers is simple: can you get reasoning into a small model without paying the full RL cost? The answer is yes, two ways, and both are what let the open ecosystem catch up to the frontier reasoning labs in a matter of months. Chain-of-thought distillation, and rejection-sampling fine-tuning — RFT, also called RAFT.
[SLIDE 2 — The problem: reasoning is expensive]
Recall what GRPO actually is. A policy model, a rollouts buffer, a reward signal, a critic-free advantage estimate, a KL anchor to a reference. It is a real RL loop, and it loves to diverge. When the reward landscape flattens, when the KL coefficient is mis-set, when the rollout distribution collapses onto a single high-reward string and the model stops exploring — those are all observed, real failure modes of policy-gradient fine-tuning. GRPO works, and when you need to push the frontier you may accept that cost. But for a lot of reasoning work, you do not need to push the frontier. You need a small, cheap reasoning model that is reliably good. And for that, two cheaper routes exist.
Route one, CoT distillation: take a strong reasoning teacher, have it emit think traces, SFT a smaller student on those traces. No RL in the training loop. This is the move that produced DeepSeek-R1-Distill-Qwen-thirty-two-B. Route two, RFT: let the current model generate candidates, keep only the ones the verifiable reward accepts, retrain on the winners. A middle path — you still need a reward, but you avoid the instability of policy gradients. The key point, and it is load-bearing: both of these are terminal techniques. Not just warmup steps before you graduate to GRPO. That is the finding from arXiv two-five-zero-four-point-one-one-three-four-three that this module hinges on, and we will get to it.
[SLIDE 3 — CoT distillation: borrow the reasoning]
Chain-of-thought distillation is structurally simple. You have a strong reasoning teacher — a frontier model with thinking enabled. DeepSeek-R1, OpenAI o-one, or a Claude or GPT-class model invoked with extended thinking. You give it problems. It produces solutions that include an explicit reasoning trace, conventionally wrapped in think tags. You collect those traces, curate them — filter for correctness, deduplicate, balance difficulty — and SFT a smaller student on the resulting problem, trace, answer tuples. The student learns to emit the reasoning trace as part of its generation.
Two things to notice. First, this is SFT, not RL. There is no reward model in the training loop, no policy gradient, no KL anchor. The teacher did the expensive search once at data-generation time; the student just imitates. The compute profile is that of an ordinary SFT run. Second, the student is learning to reason in the teacher's style. The trace is part of the target text, so the student is trained to produce the chain of thought token by token. At inference, the student generates its own think block before committing to an answer. That is what makes distillation produce a genuine reasoning model, not a model that merely memorized answers.
Now frame this against FT zero-zero. The student is not learning new reasoning ability the base did not have — the Qwen base already saw enormous amounts of math and code during pretraining. Distillation is steering the student to reliably emit a structured trace and to use the reasoning pathways the base already possesses. The teacher's trace is the steering wheel. This is why a distilled model can punch above its pretraining weight class — the capability was latent; distillation routes probability mass through it. And here is the limit: distillation cannot make the student exceed the teacher. You are imitating the teacher's traces; the ceiling is the teacher's ceiling, minus whatever the smaller model forgets. If you need to push beyond what the teacher can produce, you need RL on the student's own rollouts — that is FT fourteen, or RFT.
[SLIDE 4 — The headline: R1-Distill-Qwen-32B]
The result that made distillation the standard, accessible technique. DeepSeek took their full R-one model — a frontier reasoner trained with full RL on verifiable rewards, the FT fourteen lineage — and used it as a teacher. They generated a large corpus of reasoning traces, curated them down to roughly eight hundred thousand samples spanning math, code, and general reasoning, and SFT'd an off-the-shelf Qwen thirty-two-B base on those traces. No RL on the student. Just SFT on the distilled data.
The result: R-one-Distill-Qwen-thirty-two-B beats OpenAI o-one-mini on several benchmarks, including AIME twenty twenty-four and MATH-five hundred. A thirty-two-B model, trained with nothing more than supervised fine-tuning on data generated by a stronger model, outperforms a frontier compressed-reasoning product. That single fact is why the open ecosystem got small reasoning models cheaply. Distillation became the default recipe: find or train a strong teacher, generate traces, curate, SFT. The R-one-Distill family — Qwen from one-point-five-B up to seventy-B, Llama eight-B and seventy-B — demonstrated that the recipe scales down to consumer-GPU sizes and up to frontier-adjacent quality. This is the clearest empirical statement in the module: for getting reasoning into a small model, distillation is the cheapest path that works at scale, and it works without RL.
[SLIDE 5 — RFT / RAFT: the middle path]
Now the second route. Rejection-sampling fine-tuning — RFT, also called RAFT in the two-five-zero-four-point-one-one-three-four-three paper. The middle path. You do not have a teacher whose traces you can copy, or you want the student to learn from its own attempts. So you let the current model generate. The loop, iterated. One, generate: for each problem, sample N candidates from the current model, temperature above zero, several per problem. Two, filter by reward: score each candidate with a verifiable reward — does the math check, does the code pass tests, does the answer match. Keep only the positively-rewarded candidates. Three, retrain: SFT the model on the accepted candidates. This becomes the new current model. Four, repeat. Generate with the improved model, filter, retrain. Each round, the model is trained only on its own successes.
Notice what this shares with GRPO and what it does not. Same data-generation machinery — rollouts, verifiable reward. Radically different training step. GRPO uses the rollouts to compute a policy gradient — it learns from both the successes and the failures, pushing up the good and down the bad, with all the instability that implies. RFT throws away the failures and supervises on the successes only. You keep the reward signal; you discard the gradient noise.
[SLIDE 6 — arXiv:2504.11343: simpler than expected]
The finding that gives RFT its place in this module. The authors set up a careful comparison — rejection-sampling fine-tuning versus GRPO and PPO on math reasoning, same base model, same data, same compute. The expectation in the field was that full RL would dominate, that rejection sampling was a warmup, a poor man's RL. The result: a simple rejection-sampling baseline is surprisingly competitive with GRPO and PPO on math reasoning. Not always equal, not always better, but competitive — close enough that the simplicity and stability advantages of RFT make it a legitimate choice, not merely a stepping stone.
The lesson, and it is the module's second load-bearing claim: simpler methods should not be dismissed. RFT is cheaper than full RL — no policy-gradient machinery, no critic, no KL tuning — and dramatically more stable, because the training step is SFT. SFT does not diverge the way policy gradients do. The worst case in RFT is that you accept too few candidates and the training set is small, or you accept bad candidates because the reward is wrong. Both are data-quality problems you can diagnose by inspecting the accepted set. The worst case in GRPO is a silent mode collapse that ruins the model while the reward looks fine. RFT trades expressivity — it cannot learn from failures — for diagnosability. What you train on is exactly what you accepted.
[SLIDE 7 — The decision: distillation vs RFT vs GRPO]
This is the judgment the module exists to teach. Three techniques, one goal — reasoning in a small model. Choose by three axes. Axis one: do you have a strong teacher? If yes, distillation is on the table — it is the cheapest path, consider it first. If no, you must generate your own signal — RFT or GRPO. Axis two: is your reward verifiable? If yes, RFT and GRPO are both available. If no — preference, style, open-ended — neither applies cleanly; you are in preference-optimization territory, FT thirteen, not reasoning FT. Axis three: compute budget and stability requirements. Constrained budget, must-not-diverge requirement — RFT. SFT stability, reward-filtered data, no policy-gradient machinery. Large budget, willing to tune KL and babysit rollouts, need to push the frontier — GRPO. The most powerful, the most expensive, the most likely to find improvements RFT cannot.
In one line each. Distillation: cheapest, if you have a strong teacher and do not need the student to exceed it. RFT: middle ground; generates its own data, filters by reward, no RL instability. GRPO: most powerful, most expensive, for pushing beyond what distillation and RFT achieve. A common, defensible stack: distill first — cheap, gets you most of the way. Then RFT to self-improve on the areas the teacher was weak. Then GRPO only if RFT plateaus and you have the budget. Each stage is optional. Many production reasoning models stop at distillation.
[SLIDE 8 — The thinking-mode toggle: hybrid models]
A reasoning model that always emits a long think block pays a latency tax on every query — including the trivial ones where the answer is obvious. The frontier's answer is the hybrid model: a single model that can toggle thinking on or off, controlled by a flag in the prompt or the generation config. Qwen three is the canonical example. A Qwen three model can be invoked in thinking mode — emit the trace, then answer — or non-thinking mode — answer directly — selected per request. The toggle is not a separate model. It is the same weights, steered by a control token or system instruction. One deployed model serves both the cheap fast path — what's the capital of France — and the expensive accurate path — prove this integral converges.
The deeper idea is the thinking budget — a mechanism for adaptive compute. Rather than a binary toggle, the model is given a token budget for thinking: think for up to N tokens, then answer. This lets the model spend more compute on hard problems and less on easy ones, allocating inference cost to where it buys accuracy. The implication for fine-tuning: a hybrid model is trained on a mixture of thinking and non-thinking traces, so it learns both modes and the ability to choose. Distillation data for a hybrid model includes both long-trace examples and direct-answer examples, plus ideally examples where the difficulty warrants one or the other. More involved than pure CoT distillation, but it produces a model deployable across the whole latency-accuracy tradeoff.
[SLIDE 9 — Anti-patterns]
The anti-patterns. Distilling from a weak teacher — garbage in, garbage out. The student's reasoning ceiling is the teacher's. R-one-Distill worked because R-one is a frontier reasoner. Distilling from a seven-B base that itself cannot do the math produces a small model that confidently emits wrong chains. The teacher must be genuinely strong on the target domain. RFT without reward verification — RFT's entire signal is the filter. A noisy reward, a fuzzy matcher, a lenient LLM judge, a test suite with false positives — you train on incorrectly-accepted candidates and the model learns to produce plausible-looking wrong answers. RFT demands a verifiable reward. Ignoring RFT's stability advantage over GRPO — the most expensive anti-pattern. Reaching for GRPO by default because RL is more powerful. On many reasoning tasks RFT is competitive, cheaper, and dramatically more stable. Try RFT first when the reward is verifiable; escalate to GRPO only when RFT plateaus with budget remaining. Treating distillation as only a warmup for RL — R-one-Distill-Qwen-thirty-two-B is a shipping model, not a checkpoint. Distill, evaluate the distilled model against your target, escalate only if it falls short. And distilling traces the student cannot imitate — too long, too idiosyncratic, poor tokenizer fit produces a degraded imitation. Curate the traces.
[SLIDE 10 — The lab]
The lab is called Distill Reasoning. You generate chain-of-thought traces from a strong teacher on two hundred GSM-eight-K math problems — the teacher can be a local reasoning model or an API. You verify the final answers and keep only the correct traces. Then you SFT a small student — MiniCPM-five one-B or Qwen two-point-five one-point-five-B — on those traces, using the QLoRA workflow from FT eight. Merge. Run GSM-eight-K on the distilled model and on the un-distilled base. The lift is your distillation. Expect a measurable accuracy gain — often ten to twenty-five points — from just two hundred traces, because the base already knows arithmetic; you steered it to reason reliably and in a structured trace. The stretch goal is an RFT variant: generate from the distilled model, filter by the math reward, retrain on the winners. You will have run the full distillation loop and the first iteration of RFT by the end.
[SLIDE 11 — What you can now do]
You can now state the two cheaper-than-RL routes to a reasoning small model — CoT distillation and RFT — and why both matter even after GRPO is on the table. You can describe the R-one-Distill pipeline and why a thirty-two-B SFT-only student beat o-one-mini — the headline that made distillation the default accessible recipe. You can distinguish RFT from GRPO — same rollouts and reward, different training step — and explain RFT's structural stability advantage. You can make the three-way decision — distillation versus RFT versus GRPO — from teacher availability, reward verifiability, and compute and stability constraints. You can explain the hybrid thinking toggle and thinking budgets for adaptive compute. And you can spot the anti-patterns — weak teacher, RFT without verification, ignoring RFT's stability edge.
FT fourteen gave you the most powerful tool in the course. FT fifteen gave you the ones you will actually use first. Pillar four continues — but the next module pivots to Pillar five, alignment control, with FT sixteen on the legitimate use cases for uncensored models.
End of module FT fifteen. Duration: approximately forty-five minutes at one-hundred-forty words per minute.
# Teaching Script — Module FT15: CoT Distillation and Rejection-Sampling FT **Course**: Course 3 — LLM Fine-Tuning Masterclass **Module**: FT15 — CoT Distillation and Rejection-Sampling FT **Duration**: ~45 minutes (spoken at ~140 wpm) **Format**: Verbatim transcript with `[SLIDE N]` cues. Read aloud or use as speaker notes. --- [SLIDE 1 — Title] Welcome to module FT fifteen, CoT Distillation and Rejection-Sampling Fine-Tuning. This is Pillar Four, the reasoning pillar, and it is the direct follow-up to FT fourteen on GRPO. FT fourteen gave you the most powerful tool in the course for getting reasoning into a model — full RL on verifiable rewards. It is also the most expensive and the most unstable thing you will encounter. So the question FT fifteen answers is simple: can you get reasoning into a small model without paying the full RL cost? The answer is yes, two ways, and both are what let the open ecosystem catch up to the frontier reasoning labs in a matter of months. Chain-of-thought distillation, and rejection-sampling fine-tuning — RFT, also called RAFT. [SLIDE 2 — The problem: reasoning is expensive] Recall what GRPO actually is. A policy model, a rollouts buffer, a reward signal, a critic-free advantage estimate, a KL anchor to a reference. It is a real RL loop, and it loves to diverge. When the reward landscape flattens, when the KL coefficient is mis-set, when the rollout distribution collapses onto a single high-reward string and the model stops exploring — those are all observed, real failure modes of policy-gradient fine-tuning. GRPO works, and when you need to push the frontier you may accept that cost. But for a lot of reasoning work, you do not need to push the frontier. You need a small, cheap reasoning model that is reliably good. And for that, two cheaper routes exist. Route one, CoT distillation: take a strong reasoning teacher, have it emit think traces, SFT a smaller student on those traces. No RL in the training loop. This is the move that produced DeepSeek-R1-Distill-Qwen-thirty-two-B. Route two, RFT: let the current model generate candidates, keep only the ones the verifiable reward accepts, retrain on the winners. A middle path — you still need a reward, but you avoid the instability of policy gradients. The key point, and it is load-bearing: both of these are terminal techniques. Not just warmup steps before you graduate to GRPO. That is the finding from arXiv two-five-zero-four-point-one-one-three-four-three that this module hinges on, and we will get to it. [SLIDE 3 — CoT distillation: borrow the reasoning] Chain-of-thought distillation is structurally simple. You have a strong reasoning teacher — a frontier model with thinking enabled. DeepSeek-R1, OpenAI o-one, or a Claude or GPT-class model invoked with extended thinking. You give it problems. It produces solutions that include an explicit reasoning trace, conventionally wrapped in think tags. You collect those traces, curate them — filter for correctness, deduplicate, balance difficulty — and SFT a smaller student on the resulting problem, trace, answer tuples. The student learns to emit the reasoning trace as part of its generation. Two things to notice. First, this is SFT, not RL. There is no reward model in the training loop, no policy gradient, no KL anchor. The teacher did the expensive search once at data-generation time; the student just imitates. The compute profile is that of an ordinary SFT run. Second, the student is learning to reason in the teacher's style. The trace is part of the target text, so the student is trained to produce the chain of thought token by token. At inference, the student generates its own think block before committing to an answer. That is what makes distillation produce a genuine reasoning model, not a model that merely memorized answers. Now frame this against FT zero-zero. The student is not learning new reasoning ability the base did not have — the Qwen base already saw enormous amounts of math and code during pretraining. Distillation is steering the student to reliably emit a structured trace and to use the reasoning pathways the base already possesses. The teacher's trace is the steering wheel. This is why a distilled model can punch above its pretraining weight class — the capability was latent; distillation routes probability mass through it. And here is the limit: distillation cannot make the student exceed the teacher. You are imitating the teacher's traces; the ceiling is the teacher's ceiling, minus whatever the smaller model forgets. If you need to push beyond what the teacher can produce, you need RL on the student's own rollouts — that is FT fourteen, or RFT. [SLIDE 4 — The headline: R1-Distill-Qwen-32B] The result that made distillation the standard, accessible technique. DeepSeek took their full R-one model — a frontier reasoner trained with full RL on verifiable rewards, the FT fourteen lineage — and used it as a teacher. They generated a large corpus of reasoning traces, curated them down to roughly eight hundred thousand samples spanning math, code, and general reasoning, and SFT'd an off-the-shelf Qwen thirty-two-B base on those traces. No RL on the student. Just SFT on the distilled data. The result: R-one-Distill-Qwen-thirty-two-B beats OpenAI o-one-mini on several benchmarks, including AIME twenty twenty-four and MATH-five hundred. A thirty-two-B model, trained with nothing more than supervised fine-tuning on data generated by a stronger model, outperforms a frontier compressed-reasoning product. That single fact is why the open ecosystem got small reasoning models cheaply. Distillation became the default recipe: find or train a strong teacher, generate traces, curate, SFT. The R-one-Distill family — Qwen from one-point-five-B up to seventy-B, Llama eight-B and seventy-B — demonstrated that the recipe scales down to consumer-GPU sizes and up to frontier-adjacent quality. This is the clearest empirical statement in the module: for getting reasoning into a small model, distillation is the cheapest path that works at scale, and it works without RL. [SLIDE 5 — RFT / RAFT: the middle path] Now the second route. Rejection-sampling fine-tuning — RFT, also called RAFT in the two-five-zero-four-point-one-one-three-four-three paper. The middle path. You do not have a teacher whose traces you can copy, or you want the student to learn from its own attempts. So you let the current model generate. The loop, iterated. One, generate: for each problem, sample N candidates from the current model, temperature above zero, several per problem. Two, filter by reward: score each candidate with a verifiable reward — does the math check, does the code pass tests, does the answer match. Keep only the positively-rewarded candidates. Three, retrain: SFT the model on the accepted candidates. This becomes the new current model. Four, repeat. Generate with the improved model, filter, retrain. Each round, the model is trained only on its own successes. Notice what this shares with GRPO and what it does not. Same data-generation machinery — rollouts, verifiable reward. Radically different training step. GRPO uses the rollouts to compute a policy gradient — it learns from both the successes and the failures, pushing up the good and down the bad, with all the instability that implies. RFT throws away the failures and supervises on the successes only. You keep the reward signal; you discard the gradient noise. [SLIDE 6 — arXiv:2504.11343: simpler than expected] The finding that gives RFT its place in this module. The authors set up a careful comparison — rejection-sampling fine-tuning versus GRPO and PPO on math reasoning, same base model, same data, same compute. The expectation in the field was that full RL would dominate, that rejection sampling was a warmup, a poor man's RL. The result: a simple rejection-sampling baseline is surprisingly competitive with GRPO and PPO on math reasoning. Not always equal, not always better, but competitive — close enough that the simplicity and stability advantages of RFT make it a legitimate choice, not merely a stepping stone. The lesson, and it is the module's second load-bearing claim: simpler methods should not be dismissed. RFT is cheaper than full RL — no policy-gradient machinery, no critic, no KL tuning — and dramatically more stable, because the training step is SFT. SFT does not diverge the way policy gradients do. The worst case in RFT is that you accept too few candidates and the training set is small, or you accept bad candidates because the reward is wrong. Both are data-quality problems you can diagnose by inspecting the accepted set. The worst case in GRPO is a silent mode collapse that ruins the model while the reward looks fine. RFT trades expressivity — it cannot learn from failures — for diagnosability. What you train on is exactly what you accepted. [SLIDE 7 — The decision: distillation vs RFT vs GRPO] This is the judgment the module exists to teach. Three techniques, one goal — reasoning in a small model. Choose by three axes. Axis one: do you have a strong teacher? If yes, distillation is on the table — it is the cheapest path, consider it first. If no, you must generate your own signal — RFT or GRPO. Axis two: is your reward verifiable? If yes, RFT and GRPO are both available. If no — preference, style, open-ended — neither applies cleanly; you are in preference-optimization territory, FT thirteen, not reasoning FT. Axis three: compute budget and stability requirements. Constrained budget, must-not-diverge requirement — RFT. SFT stability, reward-filtered data, no policy-gradient machinery. Large budget, willing to tune KL and babysit rollouts, need to push the frontier — GRPO. The most powerful, the most expensive, the most likely to find improvements RFT cannot. In one line each. Distillation: cheapest, if you have a strong teacher and do not need the student to exceed it. RFT: middle ground; generates its own data, filters by reward, no RL instability. GRPO: most powerful, most expensive, for pushing beyond what distillation and RFT achieve. A common, defensible stack: distill first — cheap, gets you most of the way. Then RFT to self-improve on the areas the teacher was weak. Then GRPO only if RFT plateaus and you have the budget. Each stage is optional. Many production reasoning models stop at distillation. [SLIDE 8 — The thinking-mode toggle: hybrid models] A reasoning model that always emits a long think block pays a latency tax on every query — including the trivial ones where the answer is obvious. The frontier's answer is the hybrid model: a single model that can toggle thinking on or off, controlled by a flag in the prompt or the generation config. Qwen three is the canonical example. A Qwen three model can be invoked in thinking mode — emit the trace, then answer — or non-thinking mode — answer directly — selected per request. The toggle is not a separate model. It is the same weights, steered by a control token or system instruction. One deployed model serves both the cheap fast path — what's the capital of France — and the expensive accurate path — prove this integral converges. The deeper idea is the thinking budget — a mechanism for adaptive compute. Rather than a binary toggle, the model is given a token budget for thinking: think for up to N tokens, then answer. This lets the model spend more compute on hard problems and less on easy ones, allocating inference cost to where it buys accuracy. The implication for fine-tuning: a hybrid model is trained on a mixture of thinking and non-thinking traces, so it learns both modes and the ability to choose. Distillation data for a hybrid model includes both long-trace examples and direct-answer examples, plus ideally examples where the difficulty warrants one or the other. More involved than pure CoT distillation, but it produces a model deployable across the whole latency-accuracy tradeoff. [SLIDE 9 — Anti-patterns] The anti-patterns. Distilling from a weak teacher — garbage in, garbage out. The student's reasoning ceiling is the teacher's. R-one-Distill worked because R-one is a frontier reasoner. Distilling from a seven-B base that itself cannot do the math produces a small model that confidently emits wrong chains. The teacher must be genuinely strong on the target domain. RFT without reward verification — RFT's entire signal is the filter. A noisy reward, a fuzzy matcher, a lenient LLM judge, a test suite with false positives — you train on incorrectly-accepted candidates and the model learns to produce plausible-looking wrong answers. RFT demands a verifiable reward. Ignoring RFT's stability advantage over GRPO — the most expensive anti-pattern. Reaching for GRPO by default because RL is more powerful. On many reasoning tasks RFT is competitive, cheaper, and dramatically more stable. Try RFT first when the reward is verifiable; escalate to GRPO only when RFT plateaus with budget remaining. Treating distillation as only a warmup for RL — R-one-Distill-Qwen-thirty-two-B is a shipping model, not a checkpoint. Distill, evaluate the distilled model against your target, escalate only if it falls short. And distilling traces the student cannot imitate — too long, too idiosyncratic, poor tokenizer fit produces a degraded imitation. Curate the traces. [SLIDE 10 — The lab] The lab is called Distill Reasoning. You generate chain-of-thought traces from a strong teacher on two hundred GSM-eight-K math problems — the teacher can be a local reasoning model or an API. You verify the final answers and keep only the correct traces. Then you SFT a small student — MiniCPM-five one-B or Qwen two-point-five one-point-five-B — on those traces, using the QLoRA workflow from FT eight. Merge. Run GSM-eight-K on the distilled model and on the un-distilled base. The lift is your distillation. Expect a measurable accuracy gain — often ten to twenty-five points — from just two hundred traces, because the base already knows arithmetic; you steered it to reason reliably and in a structured trace. The stretch goal is an RFT variant: generate from the distilled model, filter by the math reward, retrain on the winners. You will have run the full distillation loop and the first iteration of RFT by the end. [SLIDE 11 — What you can now do] You can now state the two cheaper-than-RL routes to a reasoning small model — CoT distillation and RFT — and why both matter even after GRPO is on the table. You can describe the R-one-Distill pipeline and why a thirty-two-B SFT-only student beat o-one-mini — the headline that made distillation the default accessible recipe. You can distinguish RFT from GRPO — same rollouts and reward, different training step — and explain RFT's structural stability advantage. You can make the three-way decision — distillation versus RFT versus GRPO — from teacher availability, reward verifiability, and compute and stability constraints. You can explain the hybrid thinking toggle and thinking budgets for adaptive compute. And you can spot the anti-patterns — weak teacher, RFT without verification, ignoring RFT's stability edge. FT fourteen gave you the most powerful tool in the course. FT fifteen gave you the ones you will actually use first. Pillar four continues — but the next module pivots to Pillar five, alignment control, with FT sixteen on the legitimate use cases for uncensored models. --- *End of module FT fifteen. Duration: approximately forty-five minutes at one-hundred-forty words per minute.*