TL;DR
RTLC is a technique that makes a model first explain the topic to a beginner, then generate several candidate answers, and finally play the critic and pick the best one. Three sequential steps within one session, no fine-tuning, no external tools.
The key finding: models answer hard questions worst when you just ask them point-blank. The reason: the model isn't required to understand the topic before answering, so it jumps straight to generating an answer and skips the understanding part. It's like answering an exam question without reading it all the way through. The result: confident but wrong answers.
The fix: before answering, ask the model to "explain the topic to someone who knows nothing about it", find the gaps in that explanation, and simplify. It's a direct port of the Feynman technique into a prompt. That step alone adds +9.4 percentage points of accuracy. Generating 10 candidates and a final critique add another +4.6 pp.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
STEP 1 (Research: a template, no model call):
Wrap the task in a Teach-to-Learn scaffold →
system prompt: "explain the topic to a beginner, find the gaps, simplify"
STEP 2 (Teach-to-Learn: 10 parallel requests):
The model answers 10 times at temperature 0.4 →
10 independent candidate answers with reasoning
STEP 3 (Critique: 1 final request):
All 10 candidates + the original question → critic model →
analysis of each candidate's strengths/weaknesses →
final answer at temperature 0
Steps 2 and 3 are separate requests. Step 1 is just prompt preparation.
⚡ Quick version: Step 1 in a single request already delivers 70% of the effect.
Example in Practice
Task: You're hiring a product manager. Two finalists sent in a written case study breakdown. You need to pick the better one.
Prompt (quick version, Step 1 only):
Before you start the analysis, go through four Feynman-method steps:
1. STUDY the material. Carefully read both breakdowns and the evaluation questions.
2. EXPLAIN the topic to a beginner. Imagine explaining it to a friend with no product experience:
what makes a good PM case breakdown, what matters in it and what doesn't.
3. FIND THE GAPS. Where did doubts show up in your explanation?
Go back to the material and close them.
4. SIMPLIFY AND CONCLUDE. Briefly state what separates "excellent" from "good".
Only after these four steps, answer the question:
QUESTION: Who did better and why?
CANDIDATE A'S BREAKDOWN:
[paste text]
CANDIDATE B'S BREAKDOWN:
[paste text]
At the end, give your answer in this format: {"verdict": "A" or "B", "main_reason": "[one sentence]"}
Result: The model will first show the four steps, an "understanding narrative" of the topic. In step 3 it will find weak spots in its own logic. After that comes a detailed comparison of the two candidates with concrete arguments and a structured final verdict. The breakdown will be far more detailed and accurate than with a direct "who's better?" question.
Why It Works
The LLM weakness: a model doesn't "think" before answering; it generates text as an answer, following a pattern right away. When the question is hard, it easily reproduces a confident but shallow answer: it grabs the most common pattern from training and outputs it. No check for understanding ever happens.
The LLM strength: models are very good at generating explanations for beginners. That's a huge category of text in their training data. When we ask for an explanation from scratch, the model builds a coherent chain of reasoning, and it's exactly during that process that contradictions and gaps "pop out".
How the method uses this: the instruction "explain it to a beginner, find the gaps" switches the mode from "output an answer" to "build understanding". In effect, we create scaffolding: a forced intermediate step that keeps the model from jumping to a conclusion before it has worked through the material.
Control levers:
| What to change | Effect |
|---|---|
explain to a beginner → explain to an expert |
Fewer basic explanations, deeper nuances |
| N=10 candidates → N=3 | Cheaper in tokens, you lose ~4 pp of accuracy |
| Drop the critic step | You can use a majority vote instead (slightly weaker) |
| Give the critic a specific role | "You are a skeptical investor" → sharper critique |
Prompt Template
Full version (all three steps, several requests)
Requests 1-10, Teach-to-Learn:
Before answering, go through four mandatory steps:
STEP 1, STUDY: carefully read everything below.
STEP 2, EXPLAIN TO A BEGINNER: imagine explaining this to a friend with no experience in {topic}:
what matters here, how it works, what affects what.
STEP 3, FIND THE GAPS: where is your explanation uncertain?
Go back to the material and close those gaps.
STEP 4, SIMPLIFY: the main conclusion in one paragraph.
After the four steps, answer the question:
QUESTION: {task}
MATERIAL:
{text or options to analyze}
Give your answer in this format: {"final_answer": "{expected format}"}
Request 11 (Critic):
You are a critical analyst. You have been given {N} candidate answers to the same question.
For each candidate:
- Strengths
- Weaknesses and logical errors
- What's missing
Then: compare all candidates and pick the best-justified one.
Write a final answer that uses the best of all candidates
and avoids their flaws.
ORIGINAL QUESTION:
{task}
CANDIDATE ANSWERS:
{paste all answers from requests 1-10}
Final answer in this format: {"final_answer": "{expected format}"}
Placeholders:
- {topic}: the subject area of the task (product decisions, legal texts, technical solutions)
- {task}: the specific question you need answered
- {text or options}: the material to analyze
- {N}: number of candidates (10 recommended, minimum 3)
- {expected format}: what you expect in the answer (A or B, yes or no, option number)
🚀 Quick start: paste this into your chat:
Here is an RTLC prompt template. Adapt it to my task: [your task].
Ask me questions to fill in all the fields.
[paste the template above]
The LLM will ask about the task's subject area, what exactly you're evaluating, and what answer format you need, because the Teach-to-Learn structure has to know the domain and the critic has to understand the output format. It will take the pattern and adapt it to your task.
Original from the Paper
Algorithm 1: RTLC — Research, Teach-to-Learn, Critique
Input: prompt q, response pair (A, B), judge LLM f, N=10, T_cand=0.4, T_crit=0
Output: final verdict in {A, B}
Stage 1 (Research):
sys_msg := teach_to_learn_system_prompt()
user_msg := pairwise_prompt(q, A, B)
Stage 2 (Teach-to-Learn):
for i in 1..N (in parallel):
candidates[i] := f(sys_msg, user_msg, temperature=T_cand)
verdict_i := parse_json_final_answer(candidates[i])
Stage 3 (Critique):
crit_sys := critic_system_prompt()
crit_msg := original_question + serialize(candidates)
final := f(crit_sys, crit_msg, temperature=T_crit)
return parse_json_final_answer(final)
Algorithm 2: Critique reducer
Input: prompt q, candidates {c_1, ..., c_N}, judge LLM f, T_crit=0
Output: final verdict in {A, B}
crit_sys := critic_system_prompt()
serial := ""
for i in 1..N:
serial += "Answer Option " + str(i) + ":\n" + c_i.content + "\n\n"
crit_user := "Original Question: " + q + "\n\nAnswer Options:\n\n" + serial
out := f(crit_sys, crit_user, temperature=T_crit)
verdict := parse_json_final_answer(out)
return verdict
Context: The researchers tested RTLC on the task of comparing two answers (pairwise judge). The algorithms describe the exact logic: Stage 2 generates N independent verdicts, Stage 3 is a single critic call that sees all candidates at once and synthesizes the final answer.
Limitations
⚠️ Token cost: The full version (N=10 + critic) needs roughly 47 times more tokens than a regular request. On paid APIs that adds up. The scaffold alone (Step 1) is roughly 4 times the cost of a regular request.
⚠️ Systematic errors: If the model is systematically wrong on a given type of task, all 10 candidates will make the same mistake. The critic won't help. The method fixes the scatter of errors, not every error.
⚠️ Only one model: The study was run on Claude 3.7 Sonnet. How stable the results are on other models is unknown.
⚠️ Tasks with an objective answer: The method was tested on tasks with a correct answer (math, code, facts). On subjective tasks (judging creative work, matters of taste), the gain may be smaller.
⚠️ Chats without system prompts: The full version uses a system prompt (sys_msg), which plain ChatGPT doesn't expose; you get it only via the API and in Claude. In ChatGPT you'll need to fit everything into the user prompt.
How They Studied It
The researchers used the public benchmark JudgeBench: 350 hard tasks where you have to pick the better of two answers (A or B). The trick with JudgeBench is that the correct answer is objective: mathematically verified, unit-tested code, or factually correct. Not "what people liked" but "who is actually right". On these tasks even GPT-4o barely beats random guessing.
They took Claude 3.7 Sonnet and tested four conditions: a vanilla prompt, the Teach-to-Learn scaffold alone, the scaffold + a 10-vote majority, and full RTLC with the critic. The surprise was in the proportions: they expected the three steps to contribute roughly equally, but got 9.4 + 3.7 + 0.9 pp. Almost all the gain came from the teaching scaffold: what looked like "just a different prompt format" turned out to be the most powerful lever. The critic added only 0.9 pp, but in the 24 rare cases where it disagreed with the majority vote, it was right 18 times out of 24. In other words, the critic is more accurate exactly where the majority gets it wrong. That's what makes it valuable: not the average case, but rescuing the minority of correct answers.
Adaptations and Extrapolations
💡 Adaptation for reviewing your own writing
Same mechanics, but for evaluating your own texts instead of other people's answers.
Before critiquing the text, go through four steps:
STEP 1, STUDY: read the whole text as a reader, not an editor.
STEP 2, EXPLAIN TO A BEGINNER: what is the author trying to say? Retell the gist in your own words
to someone who hasn't seen the text.
STEP 3, FIND THE GAPS: where did your retelling come out fuzzy or forced?
Go back to the text and find the reason.
STEP 4, CONCLUSION: one sentence on the text's main problem (if any).
Only after these steps, give specific edits.
TEXT:
{paste text}
🔧 Technique: Step 1 alone as a universal add-on
The cheapest way to apply RTLC is to simply add the Teach-to-Learn instruction to any hard question:
Before answering, explain the topic [{question topic}]
as if you were explaining it to a smart friend with no specialized training.
Find the places where your explanation gets fuzzy, then go back and clarify.
Only after that, answer the question: {question}
That's 70% of the effect in 1 request with no extra calls.
🔧 Technique: an "honest critic" instead of a rubber-stamp critic
By default, the critic has no incentive to disagree with the majority. To sharpen the critique, add a role:
You are a skeptic. Your job is to find where the majority is wrong.
Start from the assumption that most of the candidates are wrong.
Prove otherwise or confirm the suspicion.
This strengthens the "rescue minority" effect, which is exactly what the critic is for.
Resources
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
Author: Andrea Morandi, Cisco Systems, Inc. — [email protected]
Key references from the paper: - JudgeBench [1]: Tan et al., a benchmark for evaluating LLM judges - Self-Consistency [5]: Wang et al., multiple reasoning chains - Self-Refine [6]: Madaan et al., a generate-critique-revise loop - Tree of Thoughts [10]: Yao et al., tree search over solutions - Constitutional AI [7]: Anthropic, principle-based self-critique