Source-linked AI summary
Humans are Missing from AI Coding Agent Research
Zora Z. Wang, John Yang, Kilian Lieret, Alexa Tartaglini, Valerie Chen, Yuxiang Wei, Zijian Wang, Lingming Zhang, Karthik Narasimhan, Ludwig Schmidt, Graham Neubig, Daniel Fried, Diyi Yang
TL;DR
As coding agents become more autonomous, practical usefulness is increasingly constrained by user-intent misunderstanding, limited verifiability, and difficulty controlling agent behavior. This position paper argues for human-centered coding agents, formalizes four interaction dimensions, and identifies gaps in evaluating communication and verification.
Problem
As coding agents improve at producing plausible solutions, research increasingly lacks ways to assess user-intent understanding, output verifiability, and controllability in practical use.
Method
The paper argues for shifting from agent-solo autonomy to human-centered usefulness and formalizes task alignment, steerability, verifiability, and adaptability as interaction primitives.
Results
The paper identifies four foundational capabilities spanning the human-agent task-solving cycle: task alignment, steerability, verifiability, and adaptability.
Takeaways & Limitations
Human-centered coding-agent research should optimize for people who use these systems, not only for leaderboard performance.
Takeaways & Limitations
Open coding-conversation data and widely adopted open-source tooling remain lacking, limiting systematic quantitative evaluation of grounding quality.
Abstract
from arXiv · showhide
Recent progress in AI coding agent research has led to rapid improvements in agents' ability to autonomously perform complex software engineering tasks, from editing large codebases to executing long-horizon development workflows. As these systems make strides, however, the primary bottleneck to practical usefulness increasingly shifts away from pure task-solving capability, and toward challenges in how users communicate with, supervise, and trust agents. In this position paper, we argue for a reorientation from autonomous to human-centered coding agents: systems designed not only to complete tasks, but to collaborate effectively with people. We identify four core interaction-level dimensions that characterize the human-agent task-solving loop: task alignment, verifiability, steerability, and adaptability. Finally, we outline concrete research directions to advance these dimensions, including user-involved coding environments, comprehensive verification mechanisms, and principled measures of human-agent interaction quality.
1. Introduction
AI coding agents have advanced in autonomous task completion, but practical usefulness increasingly depends on how well people can understand, supervise, and collaborate with them. The paper argues for human-centered design organized around four interaction dimensions and supported by interaction-aware infrastructure and evaluation.
- Coding agents increasingly modify real codebases, resolve complex repository issues, and execute multi-step software engineering workflows.
- As autonomy increases, practical bottlenecks increasingly involve misunderstanding user intent, difficult-to-verify outputs, and behavior that is hard to control or predict.
- Real-world programming involves iterative interaction, partial delegation, evolving goals, and continuous human oversight rather than one-shot task completion.
- The paper proposes shifting design and evaluation from maximizing agent-solo autonomy to maximizing human-centered usefulness.
- It identifies task alignment, steerability, verifiability, and adaptability as interaction dimensions spanning the human-agent task-solving cycle.
- The proposed research agenda includes user models, task-aware verification, interaction-centric evaluation signals, and applications beyond traditional software engineering.
- The position is contested, and the paper addresses counterarguments while advocating agents that augment rather than replace human developers.
2. AI for Code Today
AI-for-code research has largely optimized autonomous completion through harder benchmarks, increasingly sophisticated agent frameworks, and scalable training environments. The paper argues that this autonomy-centric direction may diverge from real-world programming, which depends on communication, oversight, intervention, and adaptation alongside humans.
- Recent coding-agent research largely defines progress through harder benchmarks, longer execution horizons, and higher standalone task success rates.
- Benchmark construction increasingly spans languages, modalities, longer horizons, and complex environments, potentially overemphasizing tasks at the difficulty tail.
- Agent frameworks scaffold language models with pipelines and tools to push toward fully autonomous engineering, often limiting human control.
- Specialized environments and curated training data support scalable training and verification, reinforcing the autonomy-centric research loop.
- The assumption that continued autonomy-focused progress yields proportional practical gains remains largely unexamined because benchmarks mismatch human-interaction settings.
- Prioritizing isolated autonomy risks overlooking communication, human oversight and intervention, and adaptation alongside humans in actual coding-agent use.
3. What Users Want
Practical coding-agent bottlenecks increasingly center on human interaction: communicating intent, steering execution, verifying outputs, and sustaining context across sessions. The paper frames these needs through four human-centered dimensions and proposes research directions for evaluating and supporting them.
- Users often face interaction bottlenecks—communicating with agents, consuming and verifying outputs, steering behavior, and adapting to changing codebases and users.
- Task Alignment: Task alignment requires agents to infer goals, resolve under-specification, surface assumptions, and revise shared task understanding as work unfolds.
- Task Alignment: Open coding-conversation data and quantitative grounding benchmarks remain scarce, while pass@k collapses communicative quality into a single success signal.
- Steerability: Steerability remains underdeveloped because current systems lack principled ways to expose meaningful control points between full autonomy and constant supervision.
- Verification: Verification should help users judge correctness through interpretable evidence, because unit tests alone can shift checking effort onto users and miss broader, heterogeneous tasks.
- Adaptability: Adaptability requires persistent user and task context plus reusable skills, yet current agents are mostly evaluated on isolated tasks and agent performance rather than user benefit.
4. Closing the Gap
The paper identifies missing human-interaction infrastructure as a bottleneck across its four pillars and proposes research directions spanning simulated users, oversight, interaction metrics, and broader application domains.
- Human-centered agent research requires infrastructure that samples user intent, judgments, and interventions at scale.Current pipelines lack these human behavior distributions, as well as task structures requiring interaction and verification beyond unit tests.
- Four high-leverage research directions target bottlenecks shared across multiple interaction dimensions.The paper frames these directions as potential solutions to infrastructure gaps rather than isolated fixes.
- Scale human modeling: Executable environments with simulated users could support training and evaluation, but faithful simulators must model preferences, expertise, diversity, and realistic failures.The authors note that generic prompting produces homogeneous, overly cooperative users.
- Scale human modeling: Real-use platforms can collect scalable preference signals, which may diverge substantially from rankings produced by static benchmarks.Copilot Arena is presented as an example of integrating preference collection into IDEs and daily coding tasks.
- Enable efficient oversight: Verification should be dynamic and task- and user-conditioned, surfacing artifacts suited to the quality judgment required.Examples include step summaries for data pipelines and visual presentations for webpage design; open questions concern verification quality, cognitive cost, and self-verification.
- Measure interaction quality: Interaction quality can be operationalized through measures such as turns needed to recover intent, intervention frequency, and human effort.Existing HCI taxonomies and large-scale trajectory analyses provide precedents for defining and validating these signals.
- Broaden application domains: Coding agents’ expanding use beyond software engineering makes intent grounding, verification, and steerability relevant to everyday users and higher-stakes tasks.The paper illustrates these needs with portfolio management, smart-home control, planning, and greenhouse monitoring.
5. Alternative Views
The paper addresses objections that human interaction will soon become unnecessary, that evaluation is too costly to scale, or that human-centered concerns belong only to product design. It argues that human participation remains relevant and that scalable proxies and interaction data can support research.
- Alternative views: Even if agents write most code, humans still provide personalized, organization-specific, or otherwise unavailable information through specification and evaluation.The paper characterizes coding as communication with machines that changes form rather than disappears.
- Alternative views: Current developer tools already span reviewing, frontend editing, completion, and debugging, indicating demand for assistance that does not simply replace programmers.The authors use this product spectrum to motivate continued study of human participation.
- Alternative views: Human evaluation is expensive, time-consuming, and difficult to standardize, especially for coding tasks requiring substantial expertise.The paper identifies irreproducibility as a consequence of inconsistent evaluation design, execution, and reporting.
- Alternative views: Scalable alternatives include reward models, LM-as-judge methods, computable code-quality metrics, user simulators, and preference collection from organic usage.The authors present standardization of these emerging approaches as an immediate research opportunity.
- Alternative views: The paper’s position is compatible with scaling, but argues that scaling toward autonomous agents alone will not produce better collaborators.It cites the shift from GPT-3 to ChatGPT as an example of human preferences changing a system’s conversational behavior.
6. Conclusion
The paper concludes that omitting humans from coding-agent research threatens practical utility and could widen the gap between benchmark progress and real-world use.
- Optimizing coding agents without considering human use risks producing systems that become more capable while fewer people can effectively wield them.The paper contrasts leaderboard optimization with attention to the people who use these systems.
Impact Statements
The paper seeks to connect HCI and agent research through measurable human-centered objectives and to reframe automation around meaningful, controllable human interaction.
- Measurable human-centered objectives could foster closer integration among machine learning, HCI, software engineering, and related fields.The paper presents this as a potential symbiosis between HCI research and agent development.
- Human-centered coding agents can amplify human judgment and initiative while remaining controllable and interpretable.Accessible interaction and verification mechanisms may also broaden participation in AI-powered programming tools.
A. Metrics
The paper computes human-centered code-quality metrics and uses them to examine whether generated code meets standards beyond functional correctness.
- The methodology computes human-centered metrics related to code quality for the paper’s graphs and additional analysis.
A.1. Patch bloat
Patch bloat compares the size of an LM-submitted patch with the human gold patch, focusing on successfully resolved SWE-bench tasks. The analysis uses average bloat and the fraction of substantially bloated patches.
- Patch bloat measures submitted-patch size relative to the human solution and can indicate over-engineering, complexity, or task-grounding issues.
- The analysis evaluates models on successfully resolved SWE-bench Verified instances using mini-swe-agent to avoid confounding from unresolved tasks.
- Submitted and gold patches are cleaned by removing newly added files, non-Python files, and test-file changes before comparison.
- The bloat ratio is the character-length ratio between submitted and gold patches, summarized by average bloat ratio and bloated patch fraction.
- All models exceed a 15% bloated patch fraction, while bloat rises with model release date and remains largely uncorrelated with task resolution rate.
A.2. Further insights on patch bloat
The patch-bloat analysis attributes longer LM patches mainly to verbose implementation, scope creep, and defensive coding, while Figure 5 shows patch sizes increasing over model releases.
- Around 60% of bloated resolved patches involve verbose implementation, while scope creep affects 50–65% and overly defensive code affects 20–30%.Excessive documentation and over-engineered solutions account for around 20–30% and 10% of bloating, respectively.
- Figure 5 tracks LM-generated patch sizes, and the reported trend is that patch sizes rise with model release date.
- Figure 6 reports the fraction of successfully resolving submissions that are longer than their human gold-patch counterparts, with dashed lines marking model averages.
- The annotation categories distinguish scope creep, excessive documentation, verbose implementation, architectural overhead, and defensive code.
- Verbose implementation means expressing the same fix with more code, whereas architectural overhead adds abstractions or generality beyond the task.
A.3. Functional differences
Functional correctness based on passing tests can miss behavioral differences between resolved submissions and gold patches. The analysis uses conservative dual-model annotation and finds frequent discrepancies, especially in newer models.
- Passing visible and hidden unit tests marks SWE-bench instances resolved, but tests may not cover all behavior details, allowing functional discrepancies to remain.
- The study cleans patches and has Claude Haiku 4.5 and GPT-5 mini classify functional differences between the problem statement, submission, and gold patch.
- The conservative criterion counts a patch as functionally discrepant only when both models flag at least one discrepancy.
- More than 50% of patches show discrepancies for all models, resolution rate is weakly correlated with increased discrepancies, and newer models have more discrepancies.
- Both models flag 66% and 62% of resolved patches individually, while 57% are flagged by both; standard and edge-case behavior each affect around one third.
- Around 20% of patches omit gold-patch functionality, and more than 10% add unrelated changes absent from the gold patch.
- The functional definition concerns observable behavior, including return values, exceptions, side effects, I/O, and externally visible state changes.
- Category annotations separate standard behavior, edge-case handling, missing functionality, unrelated changes, and fundamentally different approaches.
B.1. Complementary Considerations
The paper treats customizability, usability, proactivity, safety, and orchestration as complementary to its four core interaction primitives, while emphasizing that the framework centers on a single human-agent dyad. These considerations clarify how persistent configuration, learned initiative, safety breakdowns, and multi-party coordination relate to human-centered coding agents.
- Proactivity: Proactivity anticipates user needs without explicit instruction, but human-agent collaboration can function without it.The paper treats proactivity as a convenience-enhancing property rather than a fundamental interaction primitive.
- Proactivity: Effective proactivity emerges from adaptability because learned preferences and workflow context help agents distinguish welcome initiative from intrusive action.Static rules can implement simple proactive behaviors, but calibrated initiative requires user-specific context.
- Safety: Safety failures can result from breakdowns in existing pillars, such as insufficient steerability before irreversible actions or insufficient verification before commits.The paper therefore frames safety as context-dependent rather than as a universal standalone property.
- Orchestration: The position focuses on a single human and single coding agent, treating orchestration as a future extension that depends on well-functioning dyadic interaction primitives.Multi-party collaboration must preserve alignment, steerability, verifiability, and adaptability across handoffs and team conventions.
- Customizability: Customizability lets users configure persistent agent behavior through extensions, complementing adaptability rather than enabling the core interaction loop.It differs from steerability because it spans sessions, whereas steerability concerns in-the-moment control.
- Scope and horizon: The paper acknowledges uncertainty about whether human-centered proposals support collaboration or accelerate displacement, and limits its claim to premature optimization for full autonomy.It states that the paper is not empirically equipped to answer how full autonomy or human-AI labor markets will evolve.