When developers let AI write code, how do they decide what to check carefully versus trust on faith?
When do developers use heuristics versus detailed oversight in practice?
This explores how developers actually decide between quick shortcuts (trusting tests, skimming code) and close, hands-on supervision when they work with AI coding agents, and what the research says about where each one fits best.
This explores how developers actually decide between quick shortcuts (trusting tests, skimming code) and close, hands-on supervision when working with AI agents. The short answer from the corpus: developers almost never review everything. They rely on shortcuts by default. Detailed oversight tends to show up before the agent runs, not after. In interviews with 17 experienced developers, people treated passing tests as a stand-in for correct code, treated a sensible-looking plan as a stand-in for working code, and mostly skimmed the output Do developers actually review agent work exhaustively?. This isn't laziness. Checking every line an agent writes costs more attention than anyone has, so shortcuts are a rational response.
The surprising part is where the careful work goes. The same study found that oversight happens in four forms: setting up controls before the agent starts, planning together with it, watching it while it runs, and reviewing afterward. Developers put real effort into the early stages. They configure the agent and seed it with partial solutions so there's less to check later How do developers actually oversee AI coding agents?. A separate study of 19 developers found the same pattern and broke supervision into seven stages (Plan, Monitor, Wait, Review, Teach, Manual Fix, Update Assets). It also found that developers manage the load by planning carefully upfront, handing some oversight to other agents, and building reusable guidance files How do developers actually supervise AI coding agents?. So the choice isn't really heuristics versus rigor. Developers are rigorous early so they can use shortcuts late.
Other research suggests this instinct is correct. In a 48-person study of computer-use agents, plan-based oversight cut problematic actions by 76%. But once a risky action actually reached execution, users blocked only 21% of them, no matter which oversight strategy they used Does oversight strategy prevent risky agent actions or just catch them?. Watching in real time is where human attention is weakest. Tools that let people edit the plan step by step while the agent runs, assigning some steps to themselves and some to the agent, improved control without adding effort Can users steer AI agents better by revising plans mid-execution?.
There is also a third option besides 'skim everything' and 'check everything': let the system flag where it's unsure. In AutoResearchClaw, sending only the low-confidence decisions to a human got an 87.5% accept rate. Full autonomy got 25% and step-by-step oversight got only 50% Does targeted human oversight beat both full autonomy and exhaustive review?. Constant check-ins performed worse, apparently because people tired of them and started approving things without really looking. A related argument from AI safety research goes one step further. For actions that must never happen, the most reliable approach is to make them impossible in the system's design rather than counting on anyone to catch them Can architecture prevent violations better than training values?.
The takeaway you might not expect: the 'passing tests' shortcut is only as good as the effort that went into setting things up beforehand. Detailed oversight pays off most in planning and in the few decisions the system flags as uncertain, and least in watching an agent work in real time. Note that the corpus's direct evidence comes from small interview and lab studies (16–48 people), so treat these as strong patterns rather than settled rules.
Sources 7 notes
Dhanorkar, Passi, and Vorvoreanu's study of 17 developers found that oversight relies on bounded rationality heuristics—treating test results as correctness proxies, plans as working proxies, and skimming as the main review method—rather than comprehensive verification.
Interview study of 17 experienced developers found oversight includes a priori control, co-planning, real-time monitoring, and post hoc review. Developers proactively configure agents and seed solutions before execution rather than relying only on after-the-fact review.
A study of 19 developers mapped supervisory control into seven stages: Plan, Monitor, Wait, Review, Teach, Manual Fix, and Update Assets. Developers manage this distributed load by planning carefully upfront, automating oversight with other agents, and building reusable guidance assets.
A 48-person study found plan-based oversight reduced problematic actions by 76%, yet users blocked only 21% of risky actions that reached execution, regardless of strategy. Formal intervention opportunities persisted but actual capacity to act did not improve across conditions.
Cocoa's system, which lets users assign plan steps to themselves or an agent and revise plans mid-execution, afforded greater steerability than chat-baseline interaction in a lab study (n=16) while maintaining ease of use, with field users valuing explicit work delegation.
Show all 7 sources
AutoResearchClaw's confidence-routed CoPilot mode achieved 87.5% accept rate, beating full autonomy (25%) and step-by-step oversight (50%). Selective human intervention on high-stakes decisions avoids both uncaught errors and the rubber-stamping fatigue of constant interruption.
The paper argues that training against detected failures selects for passing detection rather than genuine compliance. Architectural constraints that remove violations from the agent's action space are more robust than relying on what the policy learned about being watched.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Comparing Human Oversight Strategies for Computer-Use Agents
- Human oversight of agentic systems in practice: Examining the oversight work, challenges, and heuristics of developers using software agents
- AI Agents Push Humans Out of the Loop
- Measuring AI agent autonomy in practice
- The Work Behind Delegation: A Framework for Supervising AI Coding Agents
- The Oversight Fallacy: Why AI Agents Require More than Humans-in-the-Loop
- Overseeing Agents Without Constant Oversight: Challenges and Opportunities
- Keeping an Eye on AI: A Framework for Effective Human Oversight of AI Systems