Option 1: VF with a trivial answer (one request)

INPUT: Problem + "Proposed answer: 1"
→ Model checks → finds errors → generates the correct answer

Option 2: VF with a previous answer (two requests)

STEP 1: CoT(problem) → Answer_1
STEP 2: VF(problem, Answer_1) → check → Answer_2 (final)

Option 3: Iter-VF (N requests, for test-time scaling)

STEP 1: CoT or VF → Answer_1
STEP 2: VF(problem, Answer_1) → Answer_2
...
STEP N: VF(problem, Answer_{N-1}) → Answer_N (final)

Important: each step sees ONLY the answer from the previous step, not the full context

Task: You're building a financial model for an investor pitch. You need the break-even point: fixed costs are $45,000/month, and the contribution margin per unit is $150. How many sales a month do you need to break even?

Prompt:

Problem: The company's fixed costs are $45,000 per month. 
The contribution margin per sale is $150. 
How many sales per month are needed to reach the break-even point?

Proposed answer: 1

First, verify the proposed answer. Then give the correct answer with an explanation.

Result: The model starts by checking: "If the answer is 1 sale, revenue is $150 against $45,000 in costs, which clearly doesn't cover it". Then it writes the equation 150 × N = 45,000 and answers 300 sales. The verification step forces the model to write out the relationship between the variables explicitly, which lowers the odds of an arithmetic slip.

The LLM weakness: Autoregressive generation creates egocentrism: the model clings to its first answer. If an error slips in early in the reasoning, the model keeps building logic on top of it, because it optimizes for coherent text, not correctness.

The strength: LLMs are great critics: they find contradictions, build counterexamples, test edge cases. Verification is a cognitively simpler task than generating from scratch.

How VF exploits this: When you hand the model "someone else's" answer to check, it drops out of defend-my-output mode. Critical thinking switches on. Even if the answer "1" is absurd, the checking process makes the model state the problem conditions explicitly, write out equations and find contradictions. That structure is then used to generate the correct answer.

Control knobs:

• Trivial vs real answer: For simple tasks, "1" or "Option B" is enough. For complex ones (code, APIs), generate a first answer with regular CoT
• Number of iterations: You can stop Iter-VF after 2-5 steps; most of the gain comes in the first iterations
• Markov vs accumulation: VF passes only the answer, not the full context, which avoids context overflow and error buildup (unlike Self-Correction)

Basic VF (with a trivial answer):

Problem: {problem_description}

Proposed answer: {trivial_answer}

First, verify the proposed answer: find errors or confirm that it's correct. 
Then give the correct answer with an explanation.

Placeholders:

• {problem_description}: the full problem statement
• {trivial_answer}: for numbers, "1"; for multiple choice, "Option B"; for yes/no, "Yes"

VF with a previous answer (for hard tasks):

Problem: {problem_description}

Previous answer: {answer_from_first_request}

Verify the previous answer: find errors in the logic, calculations or approach.
Then give a corrected or confirmed answer.

Placeholders:

• {answer_from_first_request}: copy the answer from the previous request (no reasoning, just the final answer)

Iter-VF (repeated iteration):

Repeat VF with the previous answer 3-5 times. Each time:

1. Extract only the final answer from the previous output
2. Plug it into the VF template
3. Get a new answer

Critically important: pass only the answer, not the whole reasoning text.

🚀 Quick start: paste this into the chat:

Here is the Verification-First technique. Adapt it to my task: [your task]. 
Ask me questions to figure out which trivial answer to plug in.

[paste the template above]

The LLM will ask about the answer type (number, choice, text) so it can pick a meaningful trivial answer to verify.

⚠️ Weaker on knowledge-intensive tasks: VF improves reasoning (calculations, logic) but helps little when the problem is knowledge. On GPQA (science questions) the gain is ~2-3%; on GSM8K (math), up to 5-7%.

⚠️ You need a meaningful trivial answer: For code, "return 1" is useless because the model can't meaningfully check it. For open-ended tasks, use the two-step version.

⚠️ Iter-VF hits a ceiling: After 5-10 iterations the gains slow down. For further scaling, the authors recommend combining it with parallel strategies (voting across all intermediate answers).

A team from Tsinghua University tested VF on three task types: math (GSM8K, MATH500), science questions (GPQA-Diamond), and code and APIs (HumanEval, MBPP, API-Bank). They ran it on 8 models from 1B to 72B parameters (Qwen2.5, Llama3).

An interesting design detail: for math problems they used the same trivial answer "1" everywhere, and it worked even when the answer shouldn't be a number at all (coordinates, expressions). The model interpreted "1" sensibly in the context of the problem.

The key test-time scaling result: Iter-VF beat Self-Correction, PHP, Self-Consistency and Best-of-N under a limited token budget. The critical difference is the Markov property: Iter-VF passes only the answer, Self-Correction passes the whole context. Context buildup caused a catastrophic quality drop for Self-Correction.

An unexpected finding: VF works even with "thought-hidden" models (GPT-o1 and similar), where the internal reasoning is hidden. It gave +3% on MATH500 and +4% on GPQA with minimal token overhead.

Context: The basic VF prompt for math problems (Figure 2 in the paper)

Problem: [problem description]

Proposed Answer: 1

First verify the proposed answer. Then give the correct answer.

Context: The Iter-VF algorithm (Algorithm 1)

Require: LLM M, problem Q, computation budget B, (optional: initial answer A_0)
for i = 1, ..., B do
    Extract final answer A_i from M(VF(Q, A_{i-1}))
end for
return answer A_B

💡 Adapting it for text review: Instead of "check the answer", try "here's a draft email to a client; find the weak spots, then write an improved version"

Prompt:

Task: Write an email to a customer apologizing for a delivery delay.

Draft: "Hi! Your order is delayed. Sorry."

First, find the problems in the draft (tone, completeness, specifics). 
Then write an improved version.

🔧 Technique: add a verification structure → deeper analysis

Instead of just "check the answer", you can steer the check:

Verify the proposed answer against these criteria:
1. Mathematical correctness of the calculations
2. Consistency with the problem statement
3. Soundness of the reasoning

Then give the corrected answer.

💡 Extrapolation: VF + Devil's Advocate

Combine VF with role-play and ask the model to hunt for errors aggressively:

Problem: {description}

Proposed answer: {answer}

You are a skeptical auditor. Your goal is to find ALL possible errors, inaccuracies 
and weak spots in the proposed answer. Be nitpicky.

After your critique, give the corrected answer.

Paper: "Verification-First: An Extremely Cheap Way to Improve LLM Reasoning"
Authors: Shiguang Wu, Quanming Yao (Tsinghua University, Department of Electronic Engineering)
Works cited in the paper: Chain-of-Thought (Wei et al., 2022), Self-Refine (Madaan et al., 2023), Reflexion (Shinn et al., 2023)