Standalone Deep Dive · Companion to "After Transformers"
How to Read a Paper Like a Researcher: The Framework, Applied
"After Transformers" gave you a six-question framework for judging any new idea. This article does the part that actually builds the skill: running that framework, question by question, against three real papers of three different types — so you see what it looks like in practice, not just in theory, before trying it yourself.
Opening
How to Read a Paper
Example A: Chinchilla
Example B: RLHF
Example C: Reasoning Models
Common Failure Modes
Your Turn
What's Uncertain
References
Videos
Verdict
Knowing a Framework and Using It Are Different Skills
The six-question framework from "After Transformers" — what wall does this break, is the wall real, is the fix load-bearing, what would falsify it, what does it cost, has it been tried before — reads as obvious common sense on the page. It's much less obvious under real conditions: a paper with confident language, impressive-looking benchmark tables, and forty citations you haven't read, all landing in your inbox the same week as three others. This article exists to close that gap, by actually doing the exercise three times, out loud, against real papers already cited elsewhere on this site.
One honest note before starting: applying a framework to a paper you already know the ending of (Chinchilla and RLHF both "worked," historically) is easier than applying it to something genuinely uncertain. That's exactly why the third worked example is a live, still-unsettled case — to show the framework doesn't just confirm things you already believe.
The goal of this article isn't to convince you Chinchilla was right and RLHF was right — you already knew that. The goal is to show you the specific reasoning steps that would have told you so, before the field's own verdict was in.
Part 1 — Mechanics First
How Researchers Actually Read a Paper (Not Top to Bottom)
Before the six questions even apply, there's a more basic skill: most people new to research read a paper start to finish, in order, and burn out somewhere in the middle of the methods section. Experienced researchers read out of order, on purpose.
1
Abstract first, twice. Once for the general shape of the claim, once slowly to extract the exact wall being addressed — this is where you answer Framework Question 1 before reading anything else.
2
Figures and tables before the body text. A paper's core empirical claim is almost always visible in Figure 1 or the main results table — reading the prose that surrounds it before you've looked at the actual numbers means the authors' framing shapes your read of the data, instead of the other way around.
3
Conclusion and limitations section next. Most authors state their own paper's weaknesses somewhere, often briefly and near the end — reading this early tells you what to watch for, rather than discovering it as a surprise (or not discovering it at all).
4
Methods last, and only as deep as you need. Full methodological detail matters if you're trying to reproduce the result (Article 2 of this site's Foundations series) — for evaluating whether the paper's core claim holds up, you often need less method detail than you'd expect.
With that reading order in hand, the three worked examples below show the six-question framework layered on top of it.
Part 2 — Three Worked Examples
Type: A RevisionExample A — Chinchilla: Training Compute-Optimal Large Language Models
Hoffmann et al., 2022 — arXiv:2203.15556 — already cited in Articles 1 and 3 of this site's Foundations series
1What wall does it claim to break?
Prior large models (GPT-3-scale and beyond) were trained on a roughly fixed amount of data regardless of how large the model itself was — the paper claims this allocation between model size and training data was wrong, and that the same compute budget could produce a much better model with a different split.
2Is the wall real and current?
Yes — directly demonstrated, not just argued: the paper trains Chinchilla (70B parameters) on the same compute budget as Gopher (280B parameters, a much larger prior model), and Chinchilla outperforms it. This is a controlled, apples-to-apples comparison, which is exactly the kind of evidence that makes a claim credible rather than just plausible.
3Is the fix load-bearing?
Yes, clearly — this isn't a minor tweak to an existing recipe, it's a change to the fundamental resource-allocation decision every subsequent large training run has to make. You can see this in its real-world adoption: it directly changed how frontier labs allocated compute afterward.
4What would falsify it?
A clear, stated, testable claim: roughly 20 training tokens per model parameter as the compute-optimal ratio. This is falsifiable and, notably, has since been partially revised in practice — Meta's LLaMA paper (Touvron et al., 2023) deliberately trained smaller models on more tokens than Chinchilla's ratio would suggest optimal for training compute alone, because they were optimizing for cheaper inference afterward — a different objective than Chinchilla's original training-compute framing. This is a healthy sign, not a failure: a real scientific claim gets refined by later work that clarifies its actual scope.
5What does it cost relative to what it buys?
Effectively free to adopt — it's a re-allocation of a compute budget you were already spending, not an additional cost. This is part of why it was adopted so quickly and broadly.
6Was this tried before under a different name?
Related to, and a direct revision of, Kaplan et al.'s earlier 2020 scaling laws paper (Article 1) — Chinchilla doesn't contradict the existence of scaling laws, it corrects the specific shape of the optimal curve. Knowing this prior work exists is exactly what lets you see Chinchilla as a refinement, not a totally new idea from nowhere.
Framework verdict: passes cleanly on all six questions — real wall, load-bearing fix, falsifiable and since partially refined by follow-up work, low-cost adoption. A textbook example of what a strong paper looks like under this framework.
Type: Applied EngineeringExample B — InstructGPT / RLHF at Scale
Ouyang et al., 2022, "Training Language Models to Follow Instructions with Human Feedback" — arXiv:2203.02155 — building on Christiano, Leike et al.'s 2017 RLHF foundations, cited in Article 1
1What wall does it claim to break?
A raw pretrained language model predicts likely next text, which is not the same as following an instruction helpfully, honestly, and safely — the paper claims fine-tuning with human preference feedback closes this gap.
2Is the wall real and current?
Yes, and demonstrated directly: the paper reports that human raters preferred outputs from a 1.3B-parameter InstructGPT model over outputs from the 175B-parameter GPT-3 it was fine-tuned from — a much smaller, aligned model beating a much larger, unaligned one on human preference.
3Is the fix load-bearing?
Load-bearing for behavior, but worth being precise about scope: RLHF doesn't add new capabilities to the underlying model — the knowledge and raw ability still come entirely from pretraining. This is a good example of a fix that's load-bearing for one specific problem (following instructions well) while being irrelevant to a different one (raw capability) — the framework question forces you to ask "load-bearing for what, specifically."
4What would falsify it?
This is where this example is genuinely weaker than Chinchilla, and worth sitting with rather than glossing over: "helpfulness" and "harmlessness" are judged by human raters against guidelines, which is a much softer, more subjective measurement than a numeric ratio. Compounding this, Amodei et al.'s "Concrete Problems in AI Safety" (2016, predating this paper) had already named the specific failure mode to watch for — reward hacking, where a model learns to satisfy the measurable proxy (the reward model's judgment) without satisfying the actual underlying goal. A careful reader treats this as an open risk the paper itself can't fully rule out, not a solved problem.
5What does it cost relative to what it buys?
Meaningfully more expensive than Chinchilla's near-free reallocation: it requires collecting substantial human preference-comparison data, training a separate reward model, and running reinforcement learning fine-tuning — a real, ongoing operational cost, not a one-time compute reallocation.
6Was this tried before under a different name?
Yes, explicitly — this paper is largely an application, at LLM scale, of Christiano, Leike, and colleagues' 2017 RLHF paper, which established the core method years earlier on simpler tasks. Recognizing this is exactly what separates "genuinely novel mechanism" from "known mechanism applied at a new, more consequential scale" — both are valuable, but they're different kinds of contributions.
Framework verdict: strong on real-world impact and load-bearing behavior change, genuinely weaker on falsifiability — a good example of a paper that's clearly valuable despite not being a clean, fully falsifiable scientific claim in the way Chinchilla is. The framework doesn't just produce "pass/fail" — it produces a more precise, honest picture of exactly where a paper is strong and where it isn't.
Type: Live, UnsettledExample C — Process Reward Models & Test-Time Reasoning
Lightman et al., 2023, "Let's Verify Step by Step" — arXiv:2305.20050 — one of the key papers underpinning the reasoning-model direction covered in "After Transformers"
1What wall does it claim to break?
Standard "outcome" reward models only judge whether a model's final answer was correct, giving no signal about which step in a multi-step reasoning chain went wrong — the paper proposes "process" reward models that instead evaluate each intermediate reasoning step, claiming this produces more reliable multi-step reasoning.
2Is the wall real and current?
Yes — this is a genuine, well-documented limitation of outcome-only supervision: a model can reach a correct final answer via flawed intermediate reasoning (a "right answer, wrong reasons" problem), which outcome-only reward signals can't distinguish from genuinely sound reasoning.
3Is the fix load-bearing?
This is the honest, unresolved part of this example, as of September 2026: process supervision is clearly a contributing technique behind the current reasoning-model direction ("After Transformers," Part 1), but whether it is the specific load-bearing mechanism behind current frontier reasoning models, versus one useful ingredient among several (search, more training compute, better base-model capability), is not something this article — or the broader field — can currently state with full confidence, since frontier labs don't fully disclose their exact recipes.
4What would falsify it?
A clear scientific virtue of this specific paper: it directly compares process-supervised versus outcome-supervised reward models on the same benchmark (math problem-solving) and reports the process-supervised version winning — a real, falsifiable, controlled comparison, even though the paper's role in explaining today's full reasoning-model landscape remains only partially clear.
5What does it cost relative to what it buys?
Step-level human or automated labeling of reasoning chains is more expensive to collect than simple right/wrong outcome labels — a real cost, echoing the same "how expensive is the supervision signal" question raised in Example B.
6Was this tried before under a different name?
Process-level supervision has conceptual roots in earlier step-by-step reasoning research (chain-of-thought prompting and its variants) — this paper's contribution is specifically training a reward model on step-level correctness, rather than the reasoning-chain idea itself being brand new.
Framework verdict: genuinely open. The paper's own internal claim (process supervision beats outcome supervision, on this benchmark) is well-supported. Its broader significance for the reasoning-model wave is real but not fully settled — and saying so honestly, rather than retroactively treating it as more central than the current evidence supports, is itself the framework working correctly.
Part 3 — Failure Modes the Framework Catches
Common Ways Smart Readers Get a Paper Wrong
1
Being impressed by a benchmark number without checking the comparison is fair. A model "beating" a prior one only means something if trained under comparable conditions — Chinchilla's strength above came specifically from the same-compute-budget comparison; a number without that context tells you much less than it appears to.
2
Confusing "novel" with "load-bearing." Capsule Networks ("After Transformers") were genuinely novel and came from a top researcher — novelty alone didn't make the idea load-bearing enough to survive contact with scaling and hardware constraints.
3
Skipping the limitations section, or treating it as boilerplate. Example C's honest gap (process supervision's exact role in current frontier reasoning models being unclear) is precisely the kind of thing a careful limitations read — or a careful reader's own honest assessment — surfaces, and an uncritical one misses entirely.
4
Treating "this paper was highly cited" as equivalent to "this paper's core claim was correct." Citation count measures influence and discussion, not correctness — some highly-cited papers are cited specifically because later work revised or partially overturned them (exactly Chinchilla's own relationship to Kaplan et al.'s earlier scaling laws).
Part 4 — Your Turn
🧪 Exercise: Apply the Framework Yourself, With No Worked Answers
Pick one of the two papers below — both already cited elsewhere on this site — and answer all six framework questions from "After Transformers" in your own words, in writing, before looking anywhere else for an assessment of either paper. This is deliberately given without answers: the value is in doing it, not in checking it against a key.
A
Hu et al. — "LoRA: Low-Rank Adaptation" (arXiv:2106.09685), cited in Article 1 and Article 3 of this site's Foundations series.
B
Fedus, Zoph & Shazeer — "Switch Transformer" (arXiv:2101.03961), cited in Article 1 and in "After Transformers"' Mixture-of-Experts section.
A genuinely useful next step, if you want feedback: write up your six answers for one of these as a short post and share it publicly — which is exactly the Self-Assessment Deep Dive's (Article 2) eighth item, publishing your own work, applied here directly.
⚠️ What's Uncertain in This Article
Example C is deliberately left open, not resolved — as of this article's writing (September 2026), the precise role of process reward models within current frontier reasoning-model training recipes is not fully public information, since major labs do not fully disclose their exact methods. This article's own framework verdict for Example C reflects that genuine uncertainty rather than resolving it artificially for a tidier ending.
Where This Leaves You
Between this article, The Evolution of Neural Networks, and After Transformers, you now have the full arc this three-piece set was built to deliver: how the field's ideas actually evolved and why, an honest map of where things stand today, and a demonstrated, practiced method for evaluating the next paper that crosses your desk — which, per the Foundations series' own Technical Stack and Self-Assessment articles, is most of what the day-to-day work of research actually is.
🔗 Reference Links
- Hoffmann et al. — "Training Compute-Optimal Large Language Models" — Chinchilla (arXiv:2203.15556)
- Kaplan et al. — "Scaling Laws for Neural Language Models" (arXiv:2001.08361)
- Touvron et al. — "LLaMA: Open and Efficient Foundation Language Models" (arXiv:2302.13971)
- Ouyang et al. — "Training Language Models to Follow Instructions" — InstructGPT (arXiv:2203.02155)
- Amodei et al. — "Concrete Problems in AI Safety" (arXiv:1606.06565)
- Lightman et al. — "Let's Verify Step by Step" (arXiv:2305.20050)
- Hu et al. — "LoRA: Low-Rank Adaptation" (arXiv:2106.09685)
- Fedus, Zoph & Shazeer — "Switch Transformer" (arXiv:2101.03961)
- This site — The Evolution of Neural Networks
- This site — After Transformers
🎥 Recommended Videos
🧭 Closing — The Framework Is Only Real Once You've Used It
🎯 The Bottom Line
Chinchilla passed the six-question framework cleanly; InstructGPT passed on impact but revealed a genuine falsifiability weakness worth naming honestly; the process-reward-model example showed what it looks like to apply the framework to something still genuinely unresolved, rather than forcing a tidy verdict. None of these three assessments required special access or insider knowledge — every piece of evidence used above came from the papers themselves and their public reception. The exercise in Part 4 is the actual point of this article: do it once, in writing, before moving on, and you'll have practiced the specific skill this entire three-article arc was built around.