Identify and measure feedback friction in LLM reasoning tasks where models resist high-quality guidance, discovering that confidence predicts feedback receptiveness and revealing mitigation strategies.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Identify and measure feedback friction in LLM reasoning tasks where models resist high-quality guidance, discovering that confidence predicts feedback receptiveness and revealing mitigation strategies.
Feedback Friction: LLMs Struggle to Fully Incorporate External Feedback
Core Concept
Despite access to high-quality feedback from more capable models with ground-truth knowledge, large language models consistently show resistance to incorporating guidance to improve responses. This "Feedback Friction" dominates 62.8-100% of unsolved problems even under ideal conditions (frontier models, extended thinking, multiple feedback iterations). The study reveals that model confidence (measured via semantic entropy) predicts feedback receptiveness, and that feedback resistance—not feedback quality—is the limiting factor.
Architecture Overview
Systematic Feedback Framework: Three mechanisms of increasing sophistication (binary correctness, self-generated reflection, strong-model reflection) across up to 10 iterations
Monotonic Accuracy Measurement: Models retain correct answers while only modifying incorrect responses, ensuring accurate tracking
Semantic Entropy Analysis: Measures true confidence at meaning level rather than surface tokens; high correlation with feedback receptiveness
Error Categorization: Three failure types identified; feedback resistance dominates across diverse benchmarks
Tested Models: Llama-3.3-70B, Llama-4, Claude 3.7, Claude 3.7 Thinking on AIME, MATH-500, GPQA, MMLU variants
"""
F₁: Simple binary correctness signal.
Returns: "Your answer is correct" or "Your answer is incorrect"
"""
self
if
self
return
"Your answer is correct. Stop here."
else
return
"Your answer is incorrect. Please reconsider."
def
feedback_mechanism_2
self, question: str, model_response: str
str
"""
F₂: Self-generated reflective feedback.
Model generates its own analysis of why the response might be wrong.
"""
f"""
Question: {question}
Your response: {model_response}
Analyze your reasoning step-by-step:
1. What assumption did you make?
2. Could there be an error in your calculation?
3. Did you consider all constraints?
Provide honest assessment of correctness.
"""
# Model generates self-reflection
self
300
return
f"Self-analysis: {self_reflection}. Please revise your answer."
def
feedback_mechanism_3
self, question: str, model_response: str
str
"""
F₃: Strong-model reflective feedback.
GPT-4.1 mini provides expert analysis with access to ground-truth.
"""
self
f"""
Question: {question}
Model's response: {model_response}
Expected answer: {expected_answer}
Provide guidance on what went wrong and how to improve:
1. Identify the error
2. Suggest correct approach
3. Point out missed considerations
"""
# Strong model provides feedback
self
300
return
def
apply_iterative_feedback
self, question: str, max_iterations: int = 10
Dict
"""
Apply feedback iteratively up to max_iterations.
Track whether model incorporates guidance over time.
"""
self
512
for
in
range
# Evaluate current response
self
self
'iteration'
'is_correct'
'response'
'confidence'
self
if
# Correct answer found; stop iteration
break
# Select feedback mechanism
min
3
2
# Escalate feedback
if
0
self
elif
1
self
else
self
# Apply feedback and generate new response
f"""
Question: {question}
Previous response: {current_response}
Feedback: {feedback}
Based on this feedback, please provide a new, improved response:
"""
self
512
self
'iteration'
'feedback_level'
'feedback'
return
'question'
'iterations'
'final_correct'
1
'is_correct'
if
else
False
def
_extract_answer
self, response: str
str
"""Extract final answer from response."""
# Simplified: would use answer extraction based on task type
'\n'
return
1
if
else
""
def
_measure_confidence
self, response: str
float
"""Measure model confidence in response (0-1)."""
# Placeholder: actual implementation uses semantic entropy
return
0.5
Step 2: Semantic Entropy for Confidence Measurement
import numpy as np
from collections import Counter
classSemanticEntropyAnalyzer:
"""
Measures true model confidence using semantic entropy.
Operates at meaning level (multiple samples) rather than surface tokens.
Predicts feedback receptiveness.
"""def__init__(self, model, num_samples=50):
self.model = model
self.num_samples = num_samples
defcompute_semantic_entropy(self, question: str) -> float:
"""
Compute semantic entropy: uncertainty about meaning, not tokens.
Procedure:
1. Generate multiple samples from model
2. Group semantically equivalent responses
3. Compute entropy over meaning clusters
"""# Generate multiple samples
samples = []
for _ inrange(self.num_samples):
sample = self.model.generate(question, max_length=512, temperature=0.7)
samples.append(sample)
# Cluster semantically equivalent responses
clusters = self._cluster_semantic_groups(samples)
# Compute entropy over clusters
cluster_sizes = [len(c) for c in clusters]
probabilities = np.array(cluster_sizes) / len(samples)
# Shannon entropy
entropy = -np.sum(probabilities * np.log(probabilities + 1e-10))
return entropy
def_cluster_semantic_groups(self, samples: List[str]) -> List[List[str]]:
"""
Cluster samples into semantically equivalent groups.
Uses answer extraction + embedding similarity.
"""# Extract answers
answers = [self._extract_answer(s) for s in samples]
# Simple clustering: group identical answers
answer_groups = {}
for answer, sample inzip(answers, samples):
if answer notin answer_groups:
answer_groups[answer] = []
answer_groups[answer].append(sample)
returnlist(answer_groups.values())
defpredict_feedback_receptiveness(self, semantic_entropy: float) -> float:
"""
Predict probability model will accept feedback based on entropy.
Key finding: Absolute improvement rate increases from ~0 at low entropy
(high confidence, resistant to feedback) to 0.4-0.8 at high entropy
(low confidence, receptive to feedback).
"""# Empirically derived relationshipif semantic_entropy < 0.5:
receptiveness = 0.05# High confidence: very resistantelif semantic_entropy < 1.0:
receptiveness = 0.15elif semantic_entropy < 1.5:
receptiveness = 0.4# Medium confidenceelse:
receptiveness = 0.7# Low confidence: receptivereturn receptiveness
def_extract_answer(self, response: str) -> str:
"""Extract answer for semantic clustering."""return response.strip().split('\n')[-1] if response else""
Step 3: Error Analysis and Categorization
classFeedbackResistanceAnalyzer:
"""
Categorizes persistent failures into three error types.
Identifies whether failures are due to feedback quality or feedback resistance.
"""def__init__(self, model):
self.model = model
defcategorize_persistent_failure(self, question: str, feedback_history: List,
max_iterations: int = 10) -> Dict:
"""
Analyze why a problem remains unsolved after feedback iterations.
Three error categories:
1. Feedback Quality Issue: Feedback is incorrect or unhelpful
2. Comprehension Issue: Model understands feedback but can't apply it
3. Feedback Resistance: Model ignores feedback despite understanding
"""
categories = {
'feedback_quality': 0.0,
'comprehension': 0.0,
'resistance': 0.0
}
# Test 1: Verify feedback correctness
feedback_quality_score = self._verify_feedback_correctness(question, feedback_history)
categories['feedback_quality'] = feedback_quality_score
# Test 2: Model comprehension of feedback
comprehension_score = self._test_comprehension(question, feedback_history[-1])
categories['comprehension'] = comprehension_score
# Test 3: Feedback resistance (residual)
resistance_score = 1.0 - feedback_quality_score - comprehension_score
categories['resistance'] = max(0, resistance_score)
# Normalize
total = sum(categories.values())
if total > 0:
for key in categories:
categories[key] /= total
return categories
def_verify_feedback_correctness(self, question: str, feedback: List) -> float:
"""
Verify that provided feedback is actually correct.
Returns confidence that feedback accurately guides to correct answer.
"""
verification_prompt = f"""
Question: {question}
Feedback provided:
{feedback[-1] if feedback else"None"}
Is this feedback correct and helpful? (0-1)
"""# Simplified: assume feedback from GPT-4 is correctreturn0.95def_test_comprehension(self, question: str, feedback: str) -> float:
"""
Test whether model actually understands the feedback.
Ask model to explain what it should do based on feedback.
"""
comprehension_prompt = f"""
Question: {question}
Feedback: {feedback}
Based on this feedback, what is the correct approach? Explain:
"""
explanation = self.model.generate(comprehension_prompt, max_length=300)
# Score explanation against feedback content
comprehension_score = self._score_explanation(explanation, feedback)
return comprehension_score
def_score_explanation(self, explanation: str, feedback: str) -> float:
"""Score how well explanation reflects feedback understanding."""# Placeholder: would use semantic similarityreturn0.5
