Self-Correction Dynamics: When "Think Again" Helps and When It Hurts

TL;DR

Iterative self-correction, where you ask a model to double-check its own answer, works differently depending on the task format. In open-ended generation (write a text, answer in your own words), the first 1-2 re-checks give a quick quality boost, but after that the model starts to "drift": wandering off topic, adding fluff, sometimes breaking a correct answer. In multiple-choice tasks (A, B, C, D) it's the other way around: the model reliably holds on to a correct answer but almost never fixes a wrong one; it gets stuck on its first pick.

Main finding: after 1-2 iterations, self-correction stops working in nearly every case. Accuracy curves plateau or start to drop. That means an endless "think again, are you sure?" is a waste of tokens and time. Worse: in generation, extra iterations do harm: the model may swap a correct answer for a wrong one while trying to "improve" it.

The mechanics of the problem: in open-ended generation the model can rewrite anything, which gives flexibility but also risk. In multiple choice the answer space is limited, which gives stability but creates "inertia": if the probability of the correct option starts out low, even good reasoning rarely raises it enough.

Method Blueprint

SELF-CORRECTION IN GENERATION:
Iteration 0 → First answer (often with errors)
Iterations 1-2 → Obvious problems get fixed ✓
Iteration 3+ → Risk of semantic drift (going off topic, new errors) ✗

SELF-CORRECTION IN MULTIPLE-CHOICE:
Iteration 0 → First pick
Iterations 1-5 → Minimal changes (logit inertia)
If the first pick is wrong → it almost never gets fixed ✗

Example in Practice

Task: You're putting together a sales proposal for a client and ask Claude to write the text, then re-check itself several times.

How NOT to do it:

Write a sales proposal for a digital agency.
[got the text]
Double-check it and improve it.
[got version 2]
Check it again, maybe you missed something.
[got version 3]
Think again, are you sure it's all good?
[got version 4, already worse than version 2]

How to do it:

Write a sales proposal for a digital agency.
[got the text]
Check it for: logical contradictions, missed selling points, weak wording. Fix them.
[got the final version and stopped]

Result: A second iteration with a specific focus will bring an improvement. A third and beyond risk "drift": the model starts rewriting perfectly fine parts, padding with fluff, and sometimes breaking the structure.

Why It Works (and Doesn't)

The LLM weakness in self-correction: the model has no external criterion for "better or worse". It just generates new text that looks like an improvement. In the first iterations that coincides with real improvement because obvious errors get fixed. After that, the model starts changing things that don't need changing.

The "logit inertia" phenomenon in multiple choice: when the model picks an option, it forms an internal probability distribution. If option A got 0.6 and the correct B got 0.2, then even after reasoning the probabilities shift only slightly. The model is, in effect, "sure" of its first pick and looks for confirmation rather than refutation.

Semantic drift in generation: each iteration is a new generation conditioned on the previous one. The context grows, the model "forgets" the original question and starts optimizing for its previous answer rather than the task. By the 3rd-4th iteration, the link to the original request weakens.

Practical Recommendations

The 1-2 iteration rule:

[First request] → got an answer
[Once] "Double-check it for [specific criterion]" → final

For multiple-choice tasks, don't re-ask:

❌ "Are you sure? Think again"
✅ Give the context up front and ask it to justify its choice in the very first request

A hybrid strategy for important decisions:

STEP 1 (generation): "Suggest 3 possible solutions to problem X"
STEP 2 (multiple-choice): "Here are the options: [A, B, C]. Pick the best one for context Y. Justify it."

Generation to explore the solution space, structured choice for the final decision.

Limitations

⚠️ Task-dependent: on simple tasks (TinyTruthfulQA) the difference between strategies is minimal. The effects show up more strongly on hard, ambiguous questions.

⚠️ Model size: large models (14B+) handle drift in generation better, but "logit inertia" persists across all of them.

⚠️ CoT doesn't save you: Chain-of-Thought and Self-Consistency give a small boost but don't change the fundamental dynamics: the plateau after 1-2 iterations remains.

How They Studied It

A team from UCL, Amazon AGI, Sheffield and USC took 6 models of different sizes (from SmolLM2-1.7B to Gemini-2.0-Flash) and tested them on two datasets: DisambiguationQA (hard questions with referential ambiguity) and TinyTruthfulQA (factual questions designed to provoke false answers). Each dataset had parallel versions: the same questions in open-ended and multiple-choice formats. That made it possible to compare self-correction dynamics with the same content but a different output format.

The models went through up to 5 iterations of self-correction with three prompting strategies: Baseline (direct question), CoT (step-by-step reasoning) and Self-Consistency (multiple reasoning paths). The researchers tracked not just accuracy but also "flips": when an answer changed from correct to incorrect (incorrect flip) or the other way around (correct flip).

Key insight from the data: in generation, correct flips cluster in the early iterations while incorrect flips pile up in the later ones. In multiple choice there are almost no flips, good or bad. That's the adaptability vs. stability trade-off.

Adaptations and Extrapolations

💡 Adaptation for critical tasks:

If the answer has to be reliable (a legal document, medical advice), use a hybrid strategy:

1. Generate 3 possible answers to question [X]
2. Rate each one on [accuracy, completeness, risks]
3. Pick the best one and justify it

Generation creates a space of options; structured choice locks in the decision.

🔧 Technique: make the re-check criterion specific → less drift

Instead of "double-check it", give a specific focus:

• ❌ "Think again"
• ✅ "Check only for: factual errors, logical contradictions"

A specific criterion limits the model's "creative freedom" and lowers the risk of it rewriting perfectly fine parts.

Resources

Paper: "Self-Correcting Large Language Models: Generation vs. Multiple Choice"

Authors: Hossein A. Rahmani (UCL), Satyapriya Krishna (Amazon AGI / Harvard), Xi Wang (Sheffield), Mohammadmehdi Naghiaei (USC), Emine Yilmaz (UCL)

Code: github.com/rahmanidashti/llm-self-correction