The Work Behind Delegation: A Framework for Supervising AI Coding Agents

As AI coding agents carry out development tasks with greater autonomy, developers are shifting from direct implementation toward supervising delegated work. Yet existing research offers limited understanding of how developers organize supervisory activities into connected workflows. Drawing on observations and workflow diagrams from 19 experienced developers, we reconfigure Sheridan’s framework of human supervisory control into seven stages and the connecting loops for supervising AI coding agents. We applied the framework to public developer discussions on Reddit and found that supervisory demands extend across stages and that developers manage them by concentrating effort in planning, delegating supervisory work to other agents, and turning recurring guidance into reusable assets. Our framework provides a useful analytical lens for understanding how developers supervise AI coding agents by capturing how supervision is structured in agentic software development.

Introduction. AI coding tools have rapidly expanded their capabilities, moving from assisting developers [62] to carrying out software development tasks with greater autonomy [48, 61]. With the emergence of AI coding agents such as Claude Code [2] and Codex [50], developers can now provide high-level direction and leave the execution to the agent. Given a task description, agents can autonomously plan their own approach, explore the codebase, run commands, and make changes across multiple files [16, 25]. As developers delegate more of this execution to agents, their role shifts from direct implementation toward coordination and oversight [1]. Therefore, developers increasingly act as supervisors of AI coding agents, setting the direction of delegated work, tracking progress, and evaluating its output [63].

As developers take on this supervisory role, understanding what effective supervision of AI coding agents requires becomes important. Prior work has examined what developers do at particular points in the process, such as providing clear context and explicit instructions [29], asking agents to explain their changes [7], and providing corrective feedback when execution goes wrong [12]. However, supervision extends across a development task, and effort invested at one point can affect what needs to be monitored, corrected, or reviewed at subsequent points in the task [11, 15, 85]. Given limited human attention and effort, these dependencies highlight the need to consider supervision as a connected process rather than as a set of separate activities. Understanding this process requires an analytical approach that captures how supervisory activities are organized and connected across a task.

Earlier research on automation provides a useful foundation for understanding how human roles change as task execution is increasingly automated by systems such as aircraft autopilots and industrial robots [54, 70]. Among this body of work, we build on Sheridan’s framework of human supervisory control, which conceptualizes supervision as a process organized around five stages: Plan, Teach, Monitor, Intervene, and Learn [68, 69]. These stages are linked through recurrent loops, highlighting how one stage shapes subsequent supervisory demands. While Sheridan’s framework was grounded largely in automated systems that executed human-specified goals or instructions, AI coding agents have greater autonomy in determining how to accomplish delegated tasks. Hence, it remains unclear whether Sheridan’s supervisory framework can fully capture supervision under this more agentic form of delegation.

This motivates a central question for our work: How do developers organize supervision over the course of a task delegated to AI coding agents? To answer this, we developed a framework for supervising AI coding agents by reconfiguring Sheridan’s framework (Figure 1). The framework was based on a qualitative study with 19 experienced developers, where we observed participants working with agents and asked them to reconstruct their supervision workflows as diagrams. Our analysis identified seven supervisory stages—Plan, Monitor, Wait, Review, Teach, Manual Fix, and Update Assets—and loops connecting them. Together, these stages and loops capture how supervision is organized in agentic software development, providing an analytic lens for studying developer supervision of AI coding agents.

Related work. We review prior work to contextualize our framework for developer supervision of AI coding agents: (1) AI-assisted software development, (2) frameworks for human–agent collaboration, and (3) human roles in the agentic era.

2.1 AI-Assisted Software Development AI assistance in software development has shifted from providing localized code suggestions [18, 45, 57, 64] toward increasingly autonomous AI agents that can carry out development tasks with limited human intervention [19, 40, 60].

As AI systems have become more capable [16, 21], how developers interact with them has also changed.

Prior work has examined AI assistance in software development and its integration into developer workflows. Early studies focused on developers’ interactions with individual AI-generated suggestions, examining how they evaluated, accepted, and modified suggestions during programming [5, 48]. More recent work has expanded attention to AI use across programming sessions and broader development workflows, drawing on interviews with practitioners [15, 76], interaction logs from real-world use [75, 80], and longitudinal telemetry [67]. Together, these studies highlight the importance of understanding developer–AI interaction as AI becomes deeply integrated into software development.

Agentic AI introduces new dynamics of developer–AI interaction. AI agents can proactively plan and execute multi-step actions [12], incorporate broader contextual information [25], and produce artifacts across development workflows [84]. As developers delegate more execution to agents, supervision becomes increasingly important, yet its organization across a development task remains underexplored. Therefore, in this work, we examine the supervisory activities developers perform and how these activities connect throughout the process.

2.3 Human Roles in the Agentic Era The emergence of AI as a collaborator is not unique to software development. Similar shifts toward human–AI collaboration have been observed across domains such as design [10, 81], writing [39], and knowledge work [83], where AI systems have become integrated into everyday workflows. As these systems become more agentic and take on greater responsibility for execution, human roles are being reconceptualized. Rather than acting as primary executors while AI provides passive assistance, humans are increasingly shifting toward supervisory roles over delegated work by defining goals [22, 44, 76], evaluating outcomes [20], and intervening when necessary [85].

Method. We conducted a qualitative study with experienced software developers to develop a framework for supervising AI coding agents. We used Sheridan’s framework of human supervisory control [68, 69] (§3) as a theoretical starting point to examine how its stages and loops translate to the supervision of AI coding agents as developers delegate more implementation to them. We observed participants working on their own coding tasks with their usual agent setups and asked them to reconstruct their supervision workflows as diagrams. We analyzed these workflow diagrams together with task observations and think-aloud data to develop our framework, which we introduce in §5.

4.3 Procedure We conducted the study remotely over Zoom1. Each session lasted approximately 90 minutes and consisted of three phases: (1) a pre-task interview, (2) a think-aloud coding task, and (3) a supervision workflow modeling activity. All sessions were recorded and transcribed for later analysis. We describe each phase below.

4.3.1 Pre-Task Interview. We began with a semi-structured interview that expanded on participants’ initial survey responses about their development background and agent use. Participants then introduced their prepared task and the concrete goal they intended to pursue during the session. We provided brief instructions on the think-aloud protocol as needed. This phase lasted approximately 10 minutes. The full interview questions are provided in Appendix A.

4.3.2 Coding Session. In this phase, participants worked on their prepared task in their own environment, sharing their screen(s) throughout. They were asked to think aloud as they worked, and we prompted them when they remained silent for an extended period. Sessions ended when participants felt they had reached their goal, or after approximately 40 minutes had passed. In the latter case, we briefly asked how much work remained.

4.3.3 Workflow Design Session. Participants then drew a diagram of their supervision workflow on a shared online whiteboard. To examine how human supervisory control translates to AI coding agents, we first introduced Sheridan’s 1https://zoom.us/ The Work Behind Delegation: A Framework for Supervising AI Coding Agents 7 framework to participants. We emphasized that participants did not need to follow Sheridan’s stages and asked them to construct their diagrams based on their own supervision practices. The activity proceeded in three steps.

First, participants reflected on the task they had just completed and divided their supervision into stages they considered meaningful and distinct. If a stage was difficult to name concisely, they could write a short description instead. Second, they arranged the stages in order and marked recurring transitions as loops. Finally, they considered how the diagram might extend to their other tasks and to other developers, revising it accordingly. As in the coding session, participants were asked to think aloud during the activity, explaining the meaning of each stage and loop and the reasoning behind it. This phase lasted approximately 30 minutes. Example diagrams are provided in Appendix B.

Discussion. In this work, we developed a framework for supervising AI coding agents and applied it to developer discussions. Our findings suggest that delegating execution to agents redistributes supervisory work across the development process.

Building on these findings, we discuss the framework’s applicability beyond software development, design implications for agentic systems, and how the framework can be further extended as agent autonomy increases.

8.2 Design Implications for Agentic Systems We present design implications for supporting developer supervision of AI coding agents.

8.2.1 Developing AI Coding Agents. Our findings suggest several directions for developing AI coding agents that require less supervisory effort from developers. First, developers of AI coding agents should prioritize preserving developer intent throughout execution. Developers faced supervisory demands when agents deviated from intended goals, constraints, or scope (§7.1.1). Thus, agents should be designed to consistently follow the plans and constraints provided by developers, reducing the need for repeated monitoring and redirection. For example, methods for maintaining goals and constraints over longer interactions [41] or detecting when an agent’s planned actions conflict with previously specified intent [6] could help prevent such deviations before developer intervention becomes necessary.

Second, developers of AI coding agents should account for quality expectations beyond functional correctness. Even when functionality was correct, developers had to address implementations they considered repetitive, overly defensive, or difficult to maintain (§7.1.2). Hence, agents should be designed to reflect developer- and project-specific preferences in how code is produced. For instance, preference-alignment methods [59, 73] could be used to align agent outputs with preferred coding conventions, reducing the need to repeatedly correct the same quality issues.

8.2.2 Supporting Developer Supervision. Our findings also suggest several ways systems can be designed to better support developers in supervising AI coding agents. First, systems can better support developers in the planning stage prior to task delegation. Developers invested substantial effort in constructing plans that clarified goals, boundaries, and success criteria and reduced supervision later in the workflow (§7.2.1). Systems could help developers articulate these elements, identify missing or ambiguous requirements, and keep plans accessible throughout execution [22, 34, 77].

Second, systems can be designed to reduce the effort of setting up and maintaining delegated supervision. Developers reduced supervisory work by delegating monitor and review to other agents (§7.2.2) and using reusable assets such as instruction files, tests, and hooks for repeated supervision (§7.2.3). However, these arrangements required developers to configure and maintain multiple agents and assets. Systems could help developers manage these forms of delegated supervision together, making it easier to inspect, update, and reuse how supervision is set up for a task [42, 53, 74].

Finally, systems can be designed to help developers maintain an understanding of work delegated to agents. Developers actively followed and revisited agent-generated code to maintain a mental model of the codebase over time (§7.1.3). Systems could support this by highlighting important changes, connecting them to the agent’s rationale, and summarizing the context needed for developers to understand what changed and why [30, 32, 82].

Conclusion. In this work, we developed a framework for supervising AI coding agents, reconfiguring Sheridan’s framework of human supervisory control. We then applied our framework to developer discussions on agentic AI in software development and found that supervisory demands extend across stages. Developers manage such demands by shifting effort across the workflow, delegating parts of supervision, and creating reusable assets. These findings highlight that increasing autonomy of agents changes where and how human involvement is needed. Our framework provides a lens for understanding and supporting human supervision as agentic software development continues to evolve.

Limitations. and Future Work We acknowledge several limitations of our study and suggest potential future work.

First, our study for framework development captured only a limited window of participants’ development work.

Although we asked participants to bring tasks that would allow us to observe an end-to-end supervisory workflow within 40 minutes, real-world development projects often span longer periods and multiple sessions beyond what we could capture. The subsequent workflow design activity helped participants extend their diagrams beyond the observed task by considering other tasks and developers, but this still relied on retrospective reflection. Future work could examine longer-term supervision through longitudinal observations [26, 67, 78] or interaction traces [75].

Second, participants’ observed behavior and resulting workflow diagrams may have been affected by the study setting. Participants completed their tasks while being observed and thinking aloud, which may have altered how they worked. Moreover, although we introduced Sheridan’s framework to help participants reflect on how their workflows related to it and emphasized that they need not follow its structure, prior exposure may still have anchored how they segmented or represented their supervision.