Assistance or Disruption? Exploring and Evaluating the Design and Trade-offs of Proactive AI Programming Support

AI programming tools enable powerful code generation, and recent prototypes attempt to reduce user effort with proactive AI agents, but their impact on programming workflows remains unexplored. We introduce and evaluate Codellaborator, a design probe LLM agent that initiates programming assistance based on editor activities and task context. We explored three interface variants to assess trade-offs between increasingly salient AI support: prompt-only, proactive agent, and proactive agent with presence and context (Codellaborator). In a within-subject study (N= 18), we find that proactive agents increase efficiency compared to prompt-only paradigm, but also incur workflow disruptions. However, presence indicators and interaction context support alleviated disruptions and improved users’ awareness of AI processes. We underscore trade-offs of Codellaborator on user control, ownership, and code understanding, emphasizing the need to adapt proactivity to programming processes. Our research contributes to the design exploration and evaluation of proactive AI systems, presenting design implications on AI-integrated programming workflow.

Introduction. Large language models (LLMs) have enabled generative programming assistance tools to provide powerful in-situ developer support for novices and experts alike [54–56, 70, 86]. Many existing LLM-based programming tools rely on user-initiated interactions, requiring prompts or partial code snippets as input to provide sufficient context and to trigger help-seeking [52, 65, 71, 76, 86]. These systems offer help in the form of code output and natural language explanations to assist users with coding tasks. However, research indicates that users invest considerable effort in formulating prompts, interpreting responses, assessing suggestions, and integrating results into their code [52, 69, 86]. To alleviate the user intent specification costs, recent AI programming tools and designs aim to become more autonomous, allowing the system to initiate interaction and provide proactive assistance. Tools like Github Copilot [4] and Visual Studio’s IntelliCode [83] offer the auto-completion feature, which fills the code line as the user is typing, to alleviate prompt engineering efforts and proactively provide in-situ support. However, the AI tool’s generated code is not always accurate and the output still requires significant user effort to verify [60, 69, 85, 86]. To address this, commercial and research prototypes constructed intelligent AI agents with distinct focuses on the timing of assistance, the representation of the agent, and the scope of the interaction context, aiming to work with the user as collaborators and tackle coding tasks autonomously and preemptively. These approaches involve advancing on the timing of auto-completion feature to proactively make intelligent file changes with an AI caret in the code editor [13], representing the AI’s presence in the editor with an automated AI cursor [14], or grounding interactions context in different scopes, such as conversational dialogue [5, 19, 76], specific code lines [4, 52], or an agent-managed workspace to tackle software engineering tasks autonomously [15, 89, 92]. However, the effects of these new designs of system-driven programming assistance on the human workflows, compared to the existing user-initiated paradigm, remain to be explored. Visions of more “proactive1” AI programmers additionally raise questions about the potential for harm. Researchers have raised on concerns that excessive automation without proper human control can lead to unreliable and unsafe systems [79], and thus some AI systems deliberately avoid proactive AI assistance [76]. Therefore, there remain the questions of when should AI programming tools provide proactive support, how should the support be delivered, and where should the user interact with such support. Subsequently, what are the effects of a proactive AI programming tool on user experience? In which programming processes and tasks is proactivity helpful, and where might it be harmful?

This research explores the design space of proactive AI programming tools in three dimensions – the timing of assistance, the representation of the AI programming tool, and the scope of interaction context. We then evaluate the effects of this human-AI interaction paradigm on software engineering practice, illustrating the advantages and drawbacks to provide insights for future designs. We were guided by these research questions:

• RQ1: How can we design proactive assistance in an AI programming tool to reduce user effort? • RQ2: What are the benefits and drawbacks of a proactive AI programming tool compared to user-initiated systems? • RQ3: In which programming processes and task contexts can proactivity be helpful, and where can it be harmful?

To answer these research questions, we incorporate theories of interruption management, social transparency, and help-seeking behavior in programming (Fig.1) to identify specific design rationales for each dimension. Informed by prior literature, we develop Codellaborator, a technology probe [49] that employs an AI programming agent providing proactive timings of assistance to explore different forms of human-AI programming collaboration. Codellaborator’s proactive abilities allow it to initiate interaction via messages (Fig.2.a,e) in response to various user activities in the coding environment, and also to commit code edits directly in the editor (Fig.2.c). To mitigate potential disruptions, we derive three design rationales for the timing to introduce assistance and operationalize them into six design principles in the context of a coding task and an editor environment (Table 1). To evaluate designs of AI agent representations in the editor, we additionally implemented presence features for the AI agent. In Codellaborator, the agent presence is represented by a cursor and caret (Fig.2.d,b), capable of autonomous movement around the editor, signaling its action, status, and attention focus.

Related work. AI-assisted programming tools are increasingly integrated in developers’ workflows. However, even tools that prioritize productivity, such as Github Copilot [4], do not consistently demonstrate a significant improvement over traditional code completion tools such as IntelliSense [6, 56, 86]. Existing research to improve AI programming support has focused on improving the quality and usability of the code generation. For example, recent works made advancements in structuring code generation [93], expanding support to specific task domains (e.g., data analysis) [65], or highlighting high-probability 2.2 Proactive Assistance and Interruption Interruption, or “an event that breaks the coherence of an ongoing task and blocks its further flow, though allowing the primary task to resume once the interruption is removed” has been a subject of study for decades [64]. Numerous studies have highlighted the detrimental effects interruptions can have on users’ memory, emotional well-being, and ongoing task execution [24, 35, 48]. Specifically, in the context of software engineering, Solingen et al. defined interruption as a multi-phase process that occurs when a developer stops their planned activities, handles the interruption, then finally recovers by returning to the point in their work at which they were interrupted [87]. In existing practices, Ko et al. observed developers daily activities and identified multiple interruptions per day, mainly due to communication requests and notifications [58]. Parnin et al. also found that developers spend significant time rebuilding context after each interruption, creating “resumption lag” which increases errors and frustration [73, 74]. To mitigate the challenges posed by interruptions, we drew insights from psychology and behavioral science to foster collaborations that would be perceived as less disruptive. For instance, as the perceived level of disruption is influenced by a user’s mental load at the time of the interruption [24, 25, 35], we designed interactions that were aware of a 2.3.1 Help-Seeking in Programming. Developers often forage information from the code itself to resolve their issues, during processes like debugging [41]. To facilitate this process, researchers have built tools to scaffold navigation and understanding the source code [36]. Documentation is another source developers rely on to find assistance. However, studies have identified challenges for users to pinpoint relevant information and to maintain the documentation in an up-to-date state [22, 38]. Annotations on documentation, as demonstrated in Adamite, can support comprehension and foster collaboration by addressing gaps in traditional documentation [45].

Method. 3 Design Goals To investigate the effects of a proactive AI programming agent on user workflow, we used a technology probe — an instrument that is deployed to find out about the unknown—returning with useful or interesting data [49] — to explore the design space of the timing, representation, and scope of interaction (RQ1) with the following design considerations:

• DG1: Establish heuristics for timely proactive AI assistance by anticipating programmer needs based on editor activities and offering suggestions, insights, or corrections to support their tasks. • DG2: Represent AI agent’s presence using visible cues to indicate its actions, intentions, and decision-making processes, enhancing the user’s awareness of the agent’s assistance. • DG3: Provide flexible scopes of interaction by designing interactions at both a global code editor level and at a local code-line level to meet different abstractions of user need and improve context management. • DG4: Support different mechanisms in the probe and creating different versions of the system to structure comparisons and evaluations of different designs 4 The Codellaborator Probe In this section, we introduce three main components of the Codellaborator probe and how they are implemented to achieve our design goals: timely proactive support, AI agent’s visual representation, and multi-level scopes of interaction, supporting modular comparisons of different mechanisms. Below we detail the design and implementation of the probe.

4.1 Timely Proactive Programming Assistance Timing services based on context is a key consideration in AI system design [23]. To explore the design for proactive timings specifically in the context of programming support, we adopted a set of findings from research on interruption management, and distilled them down to three proactivity design principles [25, 35, 50, 67]. To operationalize, we instantiated six proactivity features in our design probe to minimize interruptions to the user (DG1), summarized in Table 1. The proactive assistance in Codellaborator serves to present one design approach that expands upon existing AI programming features, allowing us to investigate the effects of an AI agent equipped with highly proactive capabilities on users’ programming workflow. The first principle states that the most opportune moments for interruption occur during periods of low mental workload [25, 35]. In our system, we predict low mental workloads when users are not performing actions, such as writing code, moving around the file, and selecting ranges (i.e. when the user is idle). Since idleness could also mean the user is engaged in thoughts, the AI agent only intervenes after an extended period of inactivity in both editing and cursor movement, which could signal that the user is mentally stuck and needs assistance (Table 1, 1). This is a rough estimation to interpret the user’s working states, and future works could employ more advanced models to identify the user’s cognitive process. The second principle posits that people perceive interventions as less disruptive at the beginning of a task or subtask boundaries [35, 50, 67]. Task boundaries are defined as when one subtask is completed (evaluation) or when the next subtask begins (goal formulation) [67]. To convert this implication to a system feature, we used event listeners to detect users’ task beginnings and boundaries in programming, specifically, when the user completed a block of code (i.e., after outdenting in Python), executed the code, or made a multi-line edit (i.e. pasting a block of code) (Table 1, 2-4).

CHI ’25, April 26-May 1, 2025, Yokohama, Japan Pu et al.

Finally, we draw inspiration from existing AI programming tools [4, 5, 71] and propose the third principle: intervene when users are communicating through implicit signals. Existing systems don’t always use direct messages as the means of human-AI communication. For example, in Github Copilot [4], creating a new line after a comment prompts the tool to generate code based on the comment content.

Discussion. Summarizing the study results, we outlined a set of design implications for future proactive AI programming tools and identified key challenges and opportunities for human-AI programming collaboration. We further discuss the trend of transitioning from prompt-based LLM tools to more autonomous systems, exploring the potential impacts on software engineering and risks to consider.

Our design probe aimed to expand on existing guidelines on human- AI interaction, mixed-initiative interfaces [23, 47] to the context of proactive AI programming assistance. From evaluating the participant feedback and comparing three versions of the Codellaborator probe, we summarized five design implications for future systems. This is not a holistic list for designing proactivity in intelligent programming interfaces. Rather, we hope that under the rising trend of more autonomous AI tools, our study findings can provide insights and suggestions, in addition to established guidelines, on how to design the AI agent’s proactive assistance and the human-AI interplay in the specific context of programming using an LLM.

7.1.1 Facilitate code understanding instead of pure efficiency. While participants appreciated proactive coding support, the highly efficient AI generation often did not reserve time for users to develop the necessary understanding of the code logic. Since the generated code “looks very convincing (P13),” participants were tempted to accept the suggestions and proceed to the next subtask. Existing proactive AI programming features, such as the in-line autocompletion in Github Copilot, are often result-driven and strive to always provide code generations immediately, leaving users no time to internalize and think critically about the code. While this can work for repetitive processes such as refactoring, the lack of code understanding could present issues in maintainability and validation, which could aggravate in software engineering settings when scaled to larger systems. A large scaled survey on Github Copilot named troubles understanding and evaluating code as common usability issues [60]. This concern over code understanding could aggregate and require more considerations in a proactive system, where the pace of interactions is faster and the human-AI collaboration more tightly coupled.

To address this design challenge, future systems can decompose generated responses to semantic segments and present them gradually to allow time for users to fully interpret and understand the suggestions. In our design probe, the AI agent was constructed to offer hints and partial code rather than the complete solution. Participants from the study appreciated the AI’s choice to provide scaffolding (e.g. code skeleton, comments that illustrate the logical steps). Systems can also aid this code understanding process by generating explanations for code, though it is equally important to not overload the user with information, and to leave time for the user to process it by themselves.

7.1.2 Establish consensus and shared context on high-level design plan. One challenge observed from the study was that the user struggled to steer the task design in their desired direction when the agent was proactive. Since AI programming assistance often focused on a specific part of the code rather than the entire task, there was a lack of design thinking communication between the participants and the AI agent, leading to conflicts and confusion. This trend of primarily involving AI assistance for low-level tasks is consistent with studies on existing AI programming tools [69, 86].

Conclusion. As AI programming tools increasingly feature intelligent agents that proactively support workflows, we aimed to evaluate the impact of AI-initiated assistance compared to the traditional user-driven approach. We designed Codellaborator, a design probe that analyzes the user’s actions and current work state to initiate in-time, contextualized support. The AI agent employs defined heuristics derived from human collaboration principles to time the proactive assistance. Codellaborator manifests the AI agent’s visual presence in the editor to showcase the interaction process, and enables localized context management using threaded breakout messages and provenance signals. In a three-condition experiment with 18 programmers, we found that proactivity lowered users’ expression effort to convey intent to the AI, but also incurred more workflow disruptions. However, our design of Codellaborator alleviated disruptions and increased users’ awareness of the AI, resulting in a collaboration experience closer to working with a partner than a tool. From our study, we uncovered different strategies users adopted to create a balanced and productive workflow with proactive AI across different programming processes, but also revealed concerns about over-reliance, potentially leading to a loss of user control, ownership, and code understanding. Summarizing our findings, we proposed a set of design implications and outlined opportunities and risks for future systems that integrate proactive AI assistance in users’ programming workflows.

Limitations. 7.3 Limitations The novelty of this research lies in the explorative design approach that incorporates human collaboration principles in a proactive AI programming system. We implemented Codellaborator as a design probe, in an attempt to examine the usability and effect of our proactive AI support in different programming processes, in hopes of guiding future system design.