LLM Judging Is Harder Than Generation: A Three-Year-Old Assumption Falsified

Forum topic · ✨步子哥 · 2026-06-29

Summary

An Adobe Research paper by Sambaran Bandyopadhyay formally tested the assumption underlying LLM-as-a-Judge, self-reflection, and RLHF: that judging answers is easier than generating them. Using in-context QA on SQuAD 2.0, DROP, HotpotQA, and MuSiQue to eliminate parametric knowledge contamination, the study found that generation accuracy exceeded self-evaluation accuracy on three of four benchmarks. Attention analysis showed that during judging, models pay only one-third to one-fifth of the attention to context compared to generation, effectively taking a shortcut rather than verifying answers. Models also exhibit acquiescence bias, accepting incorrect answers far more often than rejecting correct ones. LoRA fine-tuning experiments revealed that generation and judging are not independent skills: training one degrades the other. Only MuSiQue, the hardest multi-hop benchmark, showed judging outperforming generation, suggesting judging is easier only when reasoning complexity is sufficiently high. The paper warns against assuming LLM judges are more reliable than the models they evaluate.

For the past three years, almost every LLM application pipeline has been built on an unverified assumption:

Judging is easier than generating.

LLM-as-a-Judge uses one model to score other models. Self-reflection has the same model generate, critique, and revise. RLHF reward models are themselves LLMs. All these architectures assume that a model's ability to judge "is this answer correct?" should be stronger than its ability to generate correct answers.

Intuitively this makes sense—grading an exam is easier than taking it, reviewing a paper is easier than writing one. Adobe Research's Sambaran Bandyopadhyay decided to formally test this assumption under controlled conditions.

The result: On three of four benchmarks, generation accuracy exceeded self-evaluation. Judging is not easier than generation—it is harder.

A Controlled Experiment: Eliminating Parametric Knowledge

Previous work had questioned "judging is easier than generating," but tested only in open-domain QA, where models might draw on stored knowledge when judging, mixing knowledge sources and preventing a clean comparison.

This paper's design is clever: it uses in-context QA—the model is given a passage and must answer questions based only on that passage. Both generation and judging rely solely on the passage, eliminating parametric knowledge interference.

Four benchmarks:

SQuAD 2.0: extractive QA on single passages
DROP: reading comprehension requiring discrete reasoning
HotpotQA: multi-hop QA
MuSiQue: multi-hop QA, harder than HotpotQA

Two models were tested. Each first generated answers, then judged whether its own just-generated answers were correct.

On 3/4 Benchmarks, Generation Beat Judging

The result was unexpected:

On SQuAD 2.0, DROP, and HotpotQA, generation accuracy was higher than self-evaluation accuracy. Only on MuSiQue (the hardest one) did evaluation slightly beat generation.

This means models are better at "solving the problem" than at "judging whether their solution is correct."

Why? Attention analysis provided the answer.

During Judging, the Model Isn't Reading the Context at All

The team analyzed attention distributions in generation versus judging modes and found a striking difference:

In judging mode, the model's attention to context is only 1/3 to 1/5 of that in generation mode.

When generating, the model reads the context carefully, finds the answer, and composes a response. When judging, the model barely looks back at the context and hardly reads the candidate answer—it behaves more like a quick "does this look right?" gut check than a careful verification.

This explains why judging is worse: judging itself isn't harder—the model is being lazy when judging. It skips the operation of "carefully comparing the answer against the context" and takes a shortcut instead.

Acquiescence Bias: The Model Is a People-Pleaser

Deeper analysis revealed a systematic bias: models tend to say "correct." In self-evaluation, the rate at which models accept wrong answers (saying "correct") far exceeds the rate at which they reject correct answers (saying "wrong").

This is "acquiescence bias"—the model defaults to "yes" unless there is strong evidence for "no." During generation, the model must actively produce content with no default to fall back on; when judging, "correct" is a low-resistance default.

LoRA Fine-Tuning: Can Training Fix This?

The team ran four LoRA fine-tuning experiments: train generation only, train judging only, train both, and train neither (baseline).

The results were more discouraging:

Training generation only: generation accuracy rose, but judging accuracy actually dropped—the model became more inclined to accept any answer (over-acceptance), including wrong ones.

Training judging only: judging accuracy barely improved, while generation accuracy degraded.

Training both: the only configuration where both improved, but the gains were limited.

This shows generation and judging are not independent skills—they share underlying mechanisms. Training one interferes with the other; there is no free lunch of "improving judging without touching generation."

The MuSiQue Exception: The Specifics of Multi-Hop Reasoning

The only benchmark where judging slightly beat generation was MuSiQue. Why?

MuSiQue requires multi-hop reasoning—answers must chain information across multiple passages. During generation, the model must complete every reasoning step itself, and an error in any step causes a wrong final answer. During judging, the model only needs to check whether the given answer is consistent with the context—it doesn't need to complete the reasoning chain itself.

This suggests a more precise conclusion: the assumption that judging is easier than generation holds only when reasoning complexity is high enough. On simple tasks, generation is actually easier, because generation forces the model to read the context carefully; when judging, the model gets lazy.

Warnings for LLM-as-a-Judge

This paper is a serious warning for current LLM evaluation pipelines:

1. Don't assume judging is easier than generation. On simple tasks this assumption is wrong. Using an LLM as a judge may be less accurate than letting the LLM solve the problem directly.

2. Attention allocation is key. Judging quality depends on whether the model is actually reading the context and candidate answers. "Lazy judging" can be detected via attention analysis.

3. LoRA cannot separate generation from judging. Trying to fine-tune a model to "only learn judging without learning generation" is unrealistic—the two share underlying capabilities.

4. Multi-hop tasks are the exception. Only when reasoning complexity is high enough is judging truly easier than generation.

A Deeper Lesson

The deepest lesson of this paper may not be the specific conclusion that "judging is harder than generation," but its methodology: when you have a widely accepted assumption, don't assume it's true—design a controlled experiment to test it.

LLM-as-a-Judge has become the industry's default configuration, powering leaderboards, automated benchmarks, and production quality evaluation. But its foundational assumption had never been cleanly validated. Now we know: on at least 3/4 of tasks, that assumption is wrong.

The next time you see evaluation results with "GPT-4 as the judge," remember: the judge may be less reliable than the players.

---

Paper link: https://arxiv.org/abs/2606.28050