Teach It Like Feynman: The 3-Stage Prompting Recipe That Made an LLM Judge 14% Smarter (No Fine-Tuning)

Abstract illustration of an AI judge teaching back a concept on a glowing board — the Feynman teach-to-learn prompting technique

If you use an LLM to grade answers, review code, or rank outputs, here's an uncomfortable truth: on the hardest objective-correctness items, even strong instruction-tuned judges barely beat random guessing. LLM-as-a-judge is now the default measurement instrument of the AI world — and the instrument is biased, lazy, and overconfident. A new paper by researcher Andrea Morandi introduces RTLC (Research, Teach-to-Learn, Critique), a three-stage prompting recipe that lifted Claude 3.7 Sonnet's pairwise accuracy on JudgeBench from 64.6% to 78.6% — a 14-point absolute gain with no fine-tuning, no retrieval, and no external tools. Here's what it does, why the science is sound, and how you can steal the recipe today.

What the researchers did

Clean infographic showing the RTLC three-stage pipeline: Research pedagogical scaffold, Teach-to-Learn ensemble of ten verdicts, and Critique pass merging into one final verdict

The core insight is borrowed from a classic of human learning: the Feynman Learning Technique. Richard Feynman claimed the best way to know whether you understand something is to teach it — you study a topic, explain it as if to a beginner, find the gaps in your explanation, and simplify. Morandi's RTLC ports that loop directly into LLM prompting, wrapped around an ensemble.

Stage 1 — Research (the pedagogical scaffold). Instead of asking the model "which answer is better?", the prompt wraps the judging task in a fixed study→teach→find-gaps→simplify sequence. The model must first research the topic of the question, then teach it back in simple terms, explicitly flag gaps in its own explanation, and only then render a verdict. Teaching forces the model to commit to facts it can defend, rather than pattern-matching its way to a snap judgment.

Stage 2 — Teach-to-Learn ensemble. The model draws N=10 independent candidate verdicts at temperature 0.4 — each one produced through the full teach-to-learn scaffold. This is an ensemble-of-thought: ten parallel judge runs, all in the same model.

Stage 3 — Critique. The same model plays critic over its own candidate set, cross-comparing the ten verdicts against the original question, then emitting one final critiqued verdict at temperature 0. One model does both jobs — no external feedback signal, no second model, no debate harness.

The paper's ablation is the most interesting part. On JudgeBench-GPT (350 hard pairwise items):

+9.4 percentage points come from the Teach-to-Learn scaffold alone (a single scaffolded verdict scores 74.0% vs. 64.6% vanilla).
+3.7 pp more from N=10 majority voting on top of the scaffold (77.7%).
+0.9 pp from the explicit critique pass (78.6% final).

Two bonus results: RTLC beats N=10 self-consistency voting head-to-head, and it sits above self-consistency at every point on the cost-accuracy frontier — for the same token spend, you always get more accuracy. It also composes orthogonally with post-hoc judge-score calibration, meaning you can stack both for multiplicative gains.

Why it matters

Every RLHF pipeline, every model-evaluation dashboard, every auto-grading tool runs on LLM-as-a-judge. If the judge is noisy, the whole measurement chain is noisy — you train on noisy preference labels, you benchmark against noisy verdicts, and you ship with false confidence. RTLC matters because it shows evaluation quality is a prompting problem you can solve at inference time, not just a model problem you need training runs to fix.

The second reason: the cheapest part is the biggest win. Nine of the fourteen points come from a single scaffolded prompt — no 10x sampling bill required. That's a rare finding: most prompting tricks either don't replicate or cost more compute than they're worth. The +9.4 pp single-shot scaffold is genuinely free performance.

The third: it crosses domains. JudgeBench spans knowledge, reasoning, math, and coding — and the error analysis shows gains in every category, not just one. Anywhere you ask a model to judge, RTLC applies.

How YOU can use it

Developer workspace showing an LLM evaluation pipeline: ten parallel judge verdicts flowing into a critique step that emits one final critiqued verdict

You don't need the paper's full harness. Here are three copy-paste prompt templates that implement each stage — steal the one that matches your budget.

Template 1 — The Feynman scaffold (free, +9.4 pp in the paper)

Wrap any judging prompt in this. Paste it before the content to be judged:

Before judging, follow these steps:

1. RESEARCH: Read the question and both answers carefully. Identify the key
   facts or concepts needed to decide correctly.

2. TEACH: Explain the correct answer to the question as if teaching a bright
   12-year-old. Keep it short, but complete.

3. FIND GAPS: Compare your explanation against each answer. Where does your
   teaching contradict or fail to support an answer? Write down those gaps.

4. SIMPLIFY: State the single decisive reason one answer is correct, in one
   sentence.

Only then: give your verdict and a one-line justification.

This alone reproduces the paper's biggest single gain. Use it everywhere a judgment is made — code reviews, answer grading, RAG output evaluation.

Template 2 — Self-consistency ensemble (the N=10 version)

Run Template 1 ten times at temperature ~0.4 (ten independent API calls, no shared context) and take the majority verdict. In the paper, this added +3.7 pp over the single scaffolded run. Cost: ~10x the tokens. Worth it when a verdict is expensive to get wrong — dataset labels, hiring-relevant grading, published benchmarks.

Template 3 — The critique pass (the full RTLC)

Take your N=10 verdicts and feed them into one final call at temperature 0:

You are a meta-judge. Below are 10 independent verdicts on the same question,
each produced by a judge that researched and taught the topic first.

[PASTE THE 10 VERDICTS WITH THEIR REASONS]

Original question and answers: [PASTE]

Task: Cross-compare the verdicts against the original question. Identify which
verdicts rest on correct facts and which rest on gaps their own teaching
exposed. Emit ONE final verdict with the single strongest reason.

In the paper, this final pass added the last +0.9 pp — small, but on top of a much stronger base, and it converts a vote into an explained decision.

The practical decision rule

Tight budget → Template 1 only (near-free, biggest slice of the gain). Judgments that feed training data or public rankings → Templates 1+2+3. And if you already calibrate judge scores post-hoc, stack calibration on top — the paper shows the two compound rather than cancel.

Key takeaways

Teaching is judging: forcing an LLM to teach the topic before rendering a verdict adds ~9.4 percentage points of accuracy — the largest single gain, at near-zero cost.
One model can be its own ensemble: 10 independent scaffolded verdicts + a self-critique pass beat self-consistency voting at every point on the cost-accuracy frontier.
No training, no tools, no second model — the whole recipe is prompt text you can paste today.
Stack it: RTLC composes multiplicatively with post-hoc score calibration.

Read the original paper: "RTLC -- Research, Teach-to-Learn, Critique: A three-stage prompting paradigm inspired by the Feynman Learning Technique that lifts LLM-as-judge accuracy on JudgeBench with no fine-tuning" — Andrea Morandi — arXiv:2605.13695 (cs.CL)