An Empirical Study of Interaction Smells in Multi-Turn Human-LLM Collaborative Code Generation

This paper introduces the concept of "Interaction Smells" in multi-turn human-LLM code generation, establishes a taxonomy based on real-world data, analyzes their distribution across leading models, and proposes the Invariant-aware Constraint Evolution (InCE) framework to effectively mitigate these issues and improve task success rates.

The Gist

Imagine you are trying to build a complex piece of furniture with a very smart, but slightly forgetful, robot assistant. You give it instructions step-by-step.

• Turn 1: "Build a table with four legs."
• Turn 2: "Actually, make the legs out of oak, and paint them blue."
• Turn 3: "Oh, and by the way, the table needs to be round, not square."

In a perfect world, the robot would remember the oak legs, the blue paint, and the round shape, building a perfect blue oak round table.

But in the real world, this paper argues that today's AI coding assistants (like the ones in GitHub Copilot or Cursor) often act like that forgetful robot. They might build a square table, forget the blue paint, or suddenly decide to use pine wood instead of oak, even though you told them otherwise three steps ago.

The authors of this paper call these mistakes "Interaction Smells." Just like a bad smell in a room tells you something is wrong without you seeing the source, these "smells" in a conversation with an AI tell you the collaboration is going off the rails.

Here is a simple breakdown of their study:

1. The Problem: The "Bad Smells" in the Conversation

The researchers looked at thousands of real conversations between humans and AI to figure out exactly how these robots mess up. They found three main categories of "smells":

• The "Vague Boss" Smell (User Intent Quality): Sometimes the human is too vague.
  • Analogy: You tell the robot, "Make it fancy." The robot doesn't know if "fancy" means gold plating, velvet cushions, or just a nice font. It guesses, and usually guesses wrong.
• The "Forgetful Assistant" Smell (Historical Instruction Compliance): The AI ignores rules you set earlier.
  • Analogy: You told the robot, "Never use red paint." In the next step, it paints the table red because it forgot your rule. Or, you said, "Use oak," and it switches to plastic.
• The "Confused Robot" Smell (Historical Response Violation): The AI contradicts itself or breaks things it already fixed.
  • Analogy: You ask the robot to fix a wobbly leg. It fixes the leg, but in doing so, it accidentally knocks over the whole table (breaking previous work). Or, it gives you the exact same answer it gave you five minutes ago, even though you asked a new question.

2. The Investigation: Who is the Worst Offender?

The researchers tested six of the most popular AI models (including GPT-4, Gemini, and various versions of Qwen) to see how often they made these mistakes.

The findings were surprising:

• The biggest problem wasn't that humans were bad at asking questions. The "Vague Boss" smells were actually rare.
• The biggest problem was that the AI forgot its own rules. The most common "smell" was "Must-Do Omission." This is when the AI is asked to add a new feature but forgets to keep the old rules (like "don't break the blue paint").
• The "Broken Fix" problem: The AI often tries to fix a small bug but accidentally breaks a feature that was working perfectly fine.

3. The Solution: The "InCE" Framework

To fix this, the authors built a new system called InCE (Invariant-aware Constraint Evolution). Think of InCE as a Project Manager standing between you and the robot.

Here is how the Project Manager works:

1. The "Rule Book" (Invariant Extraction): Before the robot starts typing code, the Project Manager reads through your entire conversation and writes down a strict "Rule Book" of everything you've ever asked for (e.g., "Must be blue," "Must use oak," "No red paint").
2. The "Safety Inspector" (Proactive Smell Detector): Before the robot sends its answer to you, the Project Manager checks the draft against the Rule Book.
   • Inspector: "Hey, you painted it red! That violates the 'No Red' rule from Turn 1."
   • Robot: "Oh, my bad. Let me fix that."
   • Inspector: "Also, you forgot to keep the oak legs. Fix that too."

4. The Results

When they used this "Project Manager" system:

• The AI got much better at remembering its rules.
• It stopped breaking things that were already working.
• It stopped giving the same answer twice in a row.
• Most importantly: The AI successfully finished the tasks much more often (the "Task Success Rate" went up).

The Big Takeaway

This paper teaches us that building software with AI isn't just about asking for code; it's about managing the conversation.

Currently, AI models are great at writing a single paragraph of code but terrible at remembering the whole story of a long project. The solution isn't just to make the AI "smarter"; it's to build systems that act like a memory keeper, constantly reminding the AI of the rules it promised to follow, ensuring that every new step builds on the last one without destroying the foundation.

Technical Summary

Here is a detailed technical summary of the paper "An Empirical Study of Interaction Smells in Multi-Turn Human-LLM Collaborative Code Generation."

1. Problem Statement

While Large Language Models (LLMs) have revolutionized code generation, their transition from static tools to dynamic, multi-turn conversational interfaces has introduced new challenges. Existing benchmarks primarily focus on the functional correctness of the final output (e.g., pass@k), overlooking latent quality issues within the interaction process itself.

The authors identify a critical gap: LLMs often struggle to maintain contextual consistency during extended dialogues. This leads to "Interaction Smells"—latent obstacles that hinder interaction convergence, disrupt developer flow, and cause performance degradation. These issues include reverting to previously fixed bugs, violating established constraints, or failing to incorporate new instructions, yet they remain largely unquantified and unaddressed in current research.

2. Methodology

The study employs a systematic empirical approach involving three main phases:

A. Data Collection and Preprocessing

• Datasets: The authors utilized real-world interaction logs from WildChat and LMSYS-Chat-1M, filtering for coding-related tasks.
• Disentanglement: They employed an LLM-assisted few-shot prompting strategy to separate multi-topic conversations into single-topic coding interactions.
• Sample Size: The final dataset included 66,371 conversation logs (19,507 multi-turn), from which 378 high-quality multi-turn samples were manually reviewed for taxonomy construction.

B. Taxonomy Construction (RQ1)

Using Open Card Sorting, the authors established the first systematic taxonomy of Interaction Smells.

• Process: An expert team (PhDs in SE/CS) and an annotation team (graduate students) iteratively analyzed dialogue logs.
• Framework: The taxonomy categorizes smells into 3 primary categories and 9 specific subtypes:
  1. User Intent Quality: Ambiguous Instruction, Incomplete Instruction.
  2. Historical Instruction Compliance: Must-Do Omission, Must-Not Violate.
  3. Historical Response Violation: Signature Mismatch, Cross-Turn Inconsistency, Partial Functionality Breakdown, Code Rollback, Repetitive Response.

C. Empirical Evaluation (RQ2)

• Models: Six mainstream LLMs were evaluated: GPT-4o, DeepSeek-Chat, Gemini 2.5, Qwen2.5-32B, Qwen2.5-72B, and Qwen3-235B-a22b.
• Simulation: A User Simulator (powered by GPT-4) was integrated into the WildBench framework to simulate iterative human feedback. The simulator provides follow-up instructions based on the model's output, creating a closed-loop evaluation environment with a maximum of 11 turns.

D. Mitigation Framework (RQ3)

The authors proposed InCE (Invariant-aware Constraint Evolution), a multi-agent framework designed to mitigate these smells:

• Invariant Extraction Module (IEM): Distills global constraints from the conversation history, filtering out transient instructions to maintain a high-priority constraint list.
• Proactive Smell Detector (PSD): Acts as a pre-generation auditor that cross-references current user intent against the invariant pool to detect potential smells (e.g., ambiguity, conflicts) before code generation occurs.

3. Key Contributions

1. First Taxonomy of Interaction Smells: Established a hierarchical framework defining 9 specific types of interaction failures in human-LLM coding tasks.
2. Empirical Distribution Analysis: Quantified the prevalence of these smells across six state-of-the-art LLMs using real-world data and simulation.
3. Novel Mitigation Framework (InCE): Introduced a lightweight, multi-agent approach that decouples constraint management from code generation, significantly improving interaction robustness.
4. Design Guidelines: Provided three practical guidelines for future human-LLM interaction systems: Explicit Constraint Maintenance, Scoped Modification Authority, and Pre-Generation Smell Detection.

4. Key Results

Distribution of Smells (RQ2)

• Most Prevalent Smell: Must-Do Omission was the dominant issue across all models, ranging from 50.00% (DeepSeek-Chat) to 78.65% (Gemini 2.5 Flash). This indicates a systemic weakness in preserving mandatory constraints when new requirements are introduced.
• Secondary Issues: Partial Functionality Breakdown (28–55%) and Repetitive Response (25–39%) were also highly prevalent.
• Low Frequency: Issues related to initial intent understanding (Ambiguous/Incomplete Instructions) were rare (<3.3%), suggesting that intent comprehension is no longer the primary bottleneck; rather, contextual consistency is the core challenge.
• Model Variance: GPT-4o generally performed best with the lowest rates of Repetitive Response (25.42%), while smaller models like Qwen2.5-32B showed higher susceptibility to functional breakdowns.

Mitigation Effectiveness (RQ3)

The InCE framework demonstrated significant improvements:

• Task Success Rate (TSR): InCE improved the TSR for 5 out of 6 models. Notable gains included Gemini 2.5 Flash (+6.67%) and GPT-4o (+5.00%).
• Smell Suppression:
  • Must-Do Omission: Reduced significantly (e.g., GPT-4o dropped from 58.86% to 45.83%).
  • Repetitive Response: Achieved double-digit reductions (e.g., Gemini 2.5 Flash dropped from 56.76% to 43.24%).
  • Partial Functionality Breakdown: Reduced from 55.17% to 50.12% for Qwen2.5-32B.
• Efficiency: While the Average Turns to Success (ATS) slightly increased for some models (due to the inclusion of previously unsolvable complex tasks), Gemini 2.5 Flash achieved a "dual victory," reducing ATS while increasing TSR, proving that eliminating futile loops accelerates convergence.

5. Significance

This paper shifts the paradigm of LLM evaluation from outcome-oriented (did the code work?) to process-oriented (was the interaction efficient and consistent?).

• Theoretical Impact: It defines "Interaction Smells" as a distinct class of failure, providing a vocabulary and taxonomy for future research in human-AI collaboration.
• Practical Impact: The InCE framework offers a deployable solution that does not require retraining models but instead augments them with explicit constraint management. This is crucial for building reliable AI coding assistants that can handle complex, multi-step software engineering tasks without degrading code quality over time.
• Future Directions: The study highlights the need for systems that explicitly manage "invariants" and "scopes of authority" to prevent destructive updates in collaborative coding environments.