Two's a Crowd: Human and AI-Based Copresence for Developers with ADHD

Abstract: Effective collaboration and communication are vital to developer productivity and well-being, yet remain constrained by human factors such as attention, intrinsic motivation, and interpersonal accountability. These constraints are particularly vital for developers identifying with Attention Deficit Hyperactivity Disorder (ADHD), who navigate persistent environmental barriers in modern hybrid workplace settings. While developers with ADHD frequently rely on collaborative copresence practices (such as body doubling or pair programming) to support executive function, the recent emergence of agentic AI coding assistants has begun reshaping these collaborative dynamics. To investigate how developers with ADHD engage in human and AI-based copresence practices, we conducted semi-structured interviews with 14 software engineers with ADHD. Our findings reveal that while traditional human-human copresence provides critical social support and onboarding structure, it forces developers to constantly manage professional reputation and sacrifice personal privacy. Conversely, developers leverage emerging human-AI copresence to maintain accountability and cognitive flow without the social anxiety, performance judgment, or surveillance associated with human observation. Based on these empirical insights, we map developer copresence practices onto core dimensions of Goffman's copresence theory and Forsgren et al.'s SPACE framework of developer productivity, and provide design recommendations for AI-based tools that promote inclusive collaboration for developers with ADHD.

• The paper evaluates how copresence (synchronous or asynchronous collaboration) supports software development focus and structure, by using I Set of 23 codes based from 14 interviews of experienced developers on the benefits, pitfalls, and best thematic areas of copresence.
• AI Coding Assistant tools used as a form of pairing, providing rapid feedback but also challenges with intellectual property, maintainability, and cognitive accountability.
• Despite the benefits of AI and human copresence, social anxiety and accountability labor remain; designers can optimize copresence by reducing the destruction of flow, providing cute mediators of social anxiety. signally reducing the constant activation energies of task initiation and flow maintenance.

Research problem and conceptual framing

“Two’s a Crowd: Human and AI-Based Copresence for Developers with ADHD” examines how software engineers with ADHD use copresence to manage executive-function demands during software development (2609.21254). The study focuses on three related practices: body doubling, pair programming, and AI-mediated copresence through agentic coding assistants. Its central claim is that copresence is not merely a collaboration format but an accessibility practice that externalizes task initiation, attention regulation, accountability, and cognitive organization.

The paper adopts a social model of disability, treating many ADHD-related difficulties as consequences of workplace structures rather than as intrinsic individual deficits. Unpredictable task assignments, fragmented asynchronous communication, continuous availability requirements, ambiguous expectations, and weak physical cues can increase the invisible access labor required to participate in conventional software workplaces. Copresence provides an external scaffold for these conditions by supplying temporal structure, social accountability, shared activity, and, in more intensive forms, direct cognitive assistance.

The theoretical analysis combines Campos-Castillo and Hitlin’s dimensions of copresence—mutual attention, mutual behavior, and mutual emotion—with Forsgren et al.’s SPACE framework for developer productivity. This combination allows the paper to connect subjective experiences of focus and anxiety with established dimensions of software-engineering work: satisfaction and well-being, communication and collaboration, and efficiency and flow. The paper’s contribution is therefore not an evaluation of AI coding accuracy. It is an interpretive account of how different forms of presence redistribute cognitive, social, and emotional labor for developers with ADHD.

Study design and evidentiary scope

The empirical basis consists of 14 semi-structured interviews with professional software developers in the United States. Participants had between 1 and 25 years of industry experience and worked in remote, hybrid, and in-person settings. Eleven participants identified as male and three as female; nine reported a formal ADHD diagnosis, while five self-identified with ADHD. All participants either had a formal diagnosis or self-identified with ADHD and scored at least 14 on the WHO Adult ADHD Self-Report Scale.

Interviews lasted approximately 60 minutes and addressed current copresence practices, associated benefits and difficulties, and possible AI-supported interventions. The authors analyzed transcripts using a flexible, reflexive thematic-analysis process. Coding produced 23 codes organized into three principal themes. The researchers explicitly did not calculate inter-rater reliability, arguing that such a metric would be inconsistent with their interpretivist and collaborative analytic approach.

The sample provides substantial variation in workplace modality and career stage, but it is not designed for statistical generalization. It is also demographically narrow in gender representation and restricted to United States-based industry professionals. The results should therefore be understood as a detailed account of experienced patterns and design tensions, not as estimates of prevalence or effect size.

Human copresence as executive-function infrastructure

Participants described body doubling as a low-intensity form of copresence in which two people work in parallel, often on unrelated tasks. Its value did not depend primarily on direct technical exchange. Instead, the visible or ambient activity of another person supplied collective momentum and lowered the threshold for task initiation. Participants used coffee shops, shared remote sessions, family members, friends, and colleagues to create a sufficiently structured environment for beginning and sustaining work.

Pomodoro-style sessions were particularly important. Participants commonly combined periods of synchronized work with predetermined breaks, using the break to disengage cognitively from a difficult task rather than continuing to process it implicitly. This temporal separation reduced cognitive fatigue and gave social interaction a bounded role. The finding has a direct design implication: sociality was beneficial when it was predictable and time-limited, but unstructured interaction could itself become a source of distraction.

Pair programming represented a more intensive modality. Whereas body doubling supplied parallel mutual behavior, pair programming required joint mutual behavior: the partners had to establish a shared plan, coordinate actions, and maintain a common representation of the codebase. Participants emphasized the importance of agreeing on concrete guardrails before coding, working in small increments, documenting decisions, and alternating active roles. Several participants used a “swapping” strategy in which each partner first learned a different subsystem and then alternated between guiding and implementing changes. This reduced the attentional cost of passively observing another person’s work and distributed system knowledge across the pair.

The paper also identifies interpersonal trust and expertise complementarity as conditions for successful human copresence. Familiar, psychologically safe partners enabled participants to ask basic questions, expose uncertainty, and receive real-time validation. Conversely, status differences and expertise mismatches could intensify performance anxiety. A senior partner operating far beyond a junior developer’s zone of proximal development could reduce rather than increase learning, because the interaction would no longer provide an accessible path between independent and assisted performance.

These findings qualify the common assumption that more synchronous collaboration necessarily improves productivity. For this population, human presence helps when it supplies structure and reciprocal support, but it can impose additional impression-management work. The partner’s personality, expertise, communication style, and expectations are not peripheral variables; they determine whether copresence functions as accommodation or surveillance.

The costs of human observation

The strongest tension in the paper concerns the coexistence of accountability and evaluative anxiety. Participants wanted the external structure produced by another person’s presence but often feared being observed while struggling, working slowly, asking elementary questions, or making mistakes. This anxiety could prevent them from initiating a session in the first place. It could also inhibit the questions needed for effective pair programming, thereby undermining the very communication that copresence was intended to support.

The paper interprets this pattern through Goffman’s account of situated interaction and the concept of impression management. Human copresence requires participants to manage a professional persona in addition to managing the technical task. Developers must decide when to speak, how to display progress, whether a pause appears legitimate, and whether requesting clarification will affect others’ judgments of their competence. For developers already managing executive dysfunction and internalized shame, this additional labor can be substantial.

Human copresence also disrupted flow under particular conditions. Participants reported that mismatched focus rhythms, unscheduled calls, on-call obligations, and interruptions could break hyperfocus and make context recovery difficult. Some participants explicitly rejected pair programming for deep coding tasks, preferring minimal ambient stimulation such as music or silent presence. The result is a modality-specific account of collaboration: active pairing may be appropriate for architecture, debugging, onboarding, and difficult conceptual decisions, whereas ambient or asynchronous copresence may better support extended implementation work.

Privacy introduced a further constraint. Screen sharing can provide visual accountability, but it may expose confidential code, proprietary information, or browsing behavior unrelated to the task. Participants therefore described a need for systems that preserve the accountability signal while obscuring sensitive content. This is not simply a usability preference. In enterprise settings governed by NDAs and data-protection policies, conventional screen-sharing-based body doubling may be structurally unavailable.

AI copresence and the redistribution of cognitive labor

All 14 participants had experience using AI for programming. Ten participants—P1, P3, P5, P6, P7, P8, P9, P10, P12, and P13—expressed positive perceptions, while four reported negative perceptions; only one participant, P11, completely avoided AI use. The paper does not treat this distribution as evidence of a population-level preference, but it does demonstrate that AI-mediated coding was already integrated into the participants’ workflows.

Participants characterized tools such as Claude Code and GitHub Copilot as pair-programming partners that could provide continuous technical interaction without interrupting flow with unrelated conversation. AI systems offered immediate feedback, codebase summarization, documentation synthesis, initial structural scaffolding, and real-time validation. Several participants did not use AI primarily for end-to-end code generation. Instead, they used it to construct a skeleton, summarize a codebase, decompose a task, or externalize a line of reasoning before manually reviewing and refining the result.

This workflow is significant for ADHD-related accessibility because it shifts some executive-function demands from internal cognition into the interaction. Prompting an agent requires the developer to articulate goals, constraints, and uncertainties. The generated summaries and task decompositions then function as external memory and working structure. In this respect, AI copresence differs from a passive productivity tool: its value lies partly in maintaining an ongoing, responsive interaction that helps stabilize attention and organize thought.

The paper makes a deliberately qualified claim about AI’s nonjudgmental character. AI copresence reduces the social anxiety associated with human observation because the system does not become bored, impatient, or evaluative in the human sense. Developers can ask basic questions, revise prompts, pause, or produce imperfect code without managing a colleague’s impression of them. This absence of mutual emotion is therefore both a deficiency and a source of psychological safety. For some participants, reduced emotional reciprocity was precisely what made AI useful during focus-intensive work.

At the same time, AI copresence transfers responsibility for verification to the individual developer. AI has no organizational accountability for production failures, architectural inconsistency, security defects, or long-term maintainability. Participants therefore preferred human copresence when they needed domain expertise, conceptual verification, or confidence that generated code satisfied a high-stakes requirement. The paper’s contradictory claim is that AI can reduce cognitive friction during implementation while increasing cognitive burden during auditing. Faster code generation does not necessarily reduce total work if the developer must inspect a large, opaque, or poorly structured output.

This boundary is particularly important for infrastructure and production systems. Participants were skeptical of using AI without human architectural oversight, arguing that rapid local optimization could obscure the larger direction of the system. The finding aligns with concerns about intent debt and cognitive debt in AI-mediated software development (Storey, 23 Mar 2026). AI can preserve local momentum while degrading shared rationale unless its actions, assumptions, and generated artifacts are made legible to collaborators.

Human–AI–human collaboration

The paper distinguishes individual human-AI copresence from hybrid sessions in which multiple human collaborators use AI simultaneously. The latter can create a new coordination failure. When one partner prompts an agent, receives generated changes, and switches screens without explaining the process, the other partner must track both the human collaborator and the agent’s rapidly changing output. Participants described this as cognitively stressful because mutual attention is fragmented across interfaces and the shared mental model is not updated at the same rate.

The problem is not AI use itself but uncoordinated delegation. In a conventional pair-programming session, the partners can observe and discuss the reasoning that leads to a code change. An agent can compress that process into a sequence of prompts and edits that is visible only to the person operating it. Unless the interaction is narrated and documented, the second developer loses access to the rationale behind the change. This creates a transition from shared reasoning to unilateral orchestration.

The paper consequently identifies transparency as a prerequisite for human–AI–human copresence. AI-generated code, prompts, intermediate decisions, and task summaries must be integrated into the shared workspace rather than remaining private to one operator. Automated summaries may support this process, but they cannot substitute for decisions about architectural intent or responsibility allocation. The design challenge is to preserve the speed of AI delegation without allowing delegation to fracture the pair’s shared mental model.

Theoretical contribution: ambient mutual attention

The paper’s principal theoretical extension is the concept of ambient mutual attention. Classical copresence theory emphasizes reciprocal attention conveyed through direct visual, auditory, or physical signals. The interviews suggest that continuous observation is not always desirable for developers with ADHD because it can induce hypervigilance and impression-management demands.

Ambient mutual attention instead uses low-fidelity signals—soft background audio, passive status indicators, IDE widgets, or other non-evaluative cues—to communicate that another person is present and engaged. The signal should be sufficient to support task initiation and persistence without requiring continuous monitoring. This reformulation separates the accountability function of presence from the surveillance function of observation.

The paper further distinguishes parallel mutual behavior from joint mutual behavior. Body doubling uses parallel activity to create momentum, while pair programming requires aligned action and shared intentionality. AI can assist the second form by generating summaries, documenting rationale, and externalizing intermediate decisions. In the paper’s terms, this can support a shift from I-awareness—knowing what another person is doing—to We-awareness—maintaining a shared understanding of why the work is proceeding in a particular direction.

Mutual emotion is also reinterpreted. Participants valued emotional reciprocity primarily during breaks, check-ins, and periods of stress rather than during active code execution. Human partners are better suited to empathy and validation, but they also introduce judgment and social expectations. AI partners lack authentic mutual emotion, yet this absence can make them preferable during technically demanding focus periods. Copresence therefore becomes modular: different partners and modalities support attention, behavior, and emotion at different stages of work.

Implications for developer productivity

The mapping to SPACE clarifies that the reported benefits cannot be reduced to code output. In the dimension of satisfaction and well-being, copresence can reduce isolation, support task initiation, and provide psychologically safe validation. However, human observation can lower well-being by increasing anxiety, especially when partners differ substantially in expertise or status. AI may improve psychological safety by removing interpersonal evaluation, but its lack of accountability can create a different form of stress.

For communication and collaboration, human pair programming supports knowledge transfer and shared understanding when partners explicitly plan, narrate decisions, and document changes. AI can accelerate this process by summarizing code and preserving intermediate reasoning. Conversely, opaque or unannounced AI delegation increases intent debt and weakens the shared mental model. The relevant outcome is therefore not the amount of communication but the quality and accessibility of shared rationale.

For efficiency and flow, body doubling and AI pair programming offer complementary mechanisms. Body doubling supplies low-intensity external structure; AI supplies immediate technical feedback and sustained interaction without ordinary social interruption. Yet both are vulnerable to disruption: human interruptions, AI latency, rigid timers, and context switching can all fragment hyperfocus. The paper’s synthesis is that a combination of human-human body doubling and human-AI pair programming may support efficiency and flow more effectively than either modality alone, but this remains a qualitative interpretation rather than a comparative experimental result.

Design recommendations

The paper derives three design implications from the interviews and the copresence framework.

Task initiation: Tools should reduce the interpersonal activation cost of finding and contacting a partner. Context-aware matching could pair developers based on task type, expected duration, or current workflow state rather than personal characteristics. Automated session setup could reduce fear of interrupting colleagues. The authors caution, however, that algorithmic matching must preserve user agency and should not turn productivity signals into compulsory performance metrics.

Flow maintenance: Systems should provide private, ambient check-ins rather than continuous surveillance or intrusive reminders. Contextually relevant prompts could reinforce accountability while remaining subordinate to the developer’s current task. For mixed-expertise pairs, automated summaries and documentation could support onboarding and learning without requiring the more experienced developer to stop coding and produce extensive notes.

Task completion and breaks: Rigid clock-based timers should be supplemented or replaced by activity-sensitive timing. AI generation latency, task boundaries, and transitions between coding and monitoring could be used to identify less disruptive opportunities for synchronized breaks. Break prompts could support social interaction when desired, but they should remain optional and controllable. The proposed systems therefore treat transitions—not only active coding—as important components of cognitive accessibility.

Limitations and open questions

The study’s conclusions are constrained by its sample of 14 self-selected U.S. developers with ADHD. Although the participants span career stages and workplace modalities, the sample is predominantly male and cannot establish how experiences vary by gender, race, diagnosis status, organizational role, or comorbid conditions. Self-identification and ASRS screening improve recruitment inclusivity but do not provide clinical characterization equivalent to a diagnostic study.

The interview method captures reported experience rather than observed behavior or longitudinal outcomes. The paper does not measure changes in task completion, defect rates, code quality, burnout, or SPACE dimensions under different copresence modalities. It therefore cannot determine whether AI copresence produces net productivity gains, whether reported flow translates into maintainable software, or whether reduced social anxiety leads to sustained occupational benefits. The claim that combined human and AI modalities optimize flow remains a hypothesis grounded in participant accounts.

Several design questions remain unresolved. It is not yet clear how an IDE could infer task boundaries without becoming another surveillance mechanism, how ambient signals should be calibrated across different ADHD experiences, or how AI-generated summaries can preserve architectural intent rather than merely restating local edits. The paper also leaves open how organizations should allocate responsibility when AI copresence accelerates implementation but human developers remain accountable for verification and production outcomes.

Conclusion

The paper presents copresence as an accessibility mechanism for developers with ADHD and differentiates its human, AI, and hybrid forms. Human copresence provides social support, accountability, onboarding, and expertise, but can impose performance anxiety, privacy costs, and flow disruption. AI copresence reduces evaluative pressure and supports cognitive externalization, yet transfers verification and accountability burdens to the developer and can damage shared mental models when used without coordination.

Its central contribution is the proposal that effective copresence need not involve continuous observation. Ambient mutual attention, explicit coordination, privacy preservation, and modality-sensitive support offer a more precise design vocabulary for inclusive software collaboration. The study does not establish causal productivity effects, but it identifies a coherent set of mechanisms and design tensions that should guide empirical evaluation of ADHD-oriented collaboration systems.