The Handoff Problem: When to Take the Keyboard Back

You delegated. The agent has been running for 40 minutes. The output is almost right. You start typing a correction. Was that the moment, or did you wait too long? Anthropic’s 2026 Agentic Coding Trends Report measures the gap directly: developers use AI in roughly 60% of their work but can fully delegate only 0 to 20% of tasks (Anthropic, 2026). The 40-to-60-point gap is where the entire discipline lives.

CodeRabbit’s December 2025 analysis of 470 open-source pull requests found AI-co-authored code produces 1.7x more issues per PR than human-only code (10.83 vs 6.45), with logic defects 75% more common and security findings 2.74x higher (CodeRabbit, 2025). The cost of delegating past your confidence threshold is rework. The cost of staying in pair mode when delegation would have shipped is invisible. “Do I trust the agent?” was the right question in 2024. By mid-2026 it is stale. Trust is a property of the tool; confidence is a property of this task, in this session, with this much information so far. The decision is a per-task confidence interval that either holds or widens past your tolerance. When it widens, you take the keyboard back. Four named cues tell you when.

Key Takeaways

• Anthropic’s 2026 trends report measures the delegation gap directly: 60% AI involvement, 0 to 20% full delegation (Anthropic, 2026).
• 66% of developers cite “AI solutions that are almost right, but not quite” as their single biggest AI frustration; that is the felt moment they should have reclaimed the keyboard (Stack Overflow, 2025).
• Experienced Claude Code users interrupt more (9% of turns) than new users (5%) while auto-approving more often; selective escalation is a learned skill (Anthropic, 2026).
• METR’s randomized controlled trial found experienced developers were 19% slower with early-2025 AI (95% CI: +2% to +39%) yet believed they were 20% faster; the cost of over-staying in delegation feels invisible (METR, 2025).

What is the delegation gap?

Anthropic’s 2026 Agentic Coding Trends Report names it directly: developers use AI in roughly 60% of their work but can fully delegate only 0 to 20% of tasks (Anthropic, 2026). The 40-to-60-point gap between use and full delegation is where every working developer in 2026 lives. The gap is not a sign agents are not ready. It is the operational signature of a discipline that does not yet have a name for the in-session decision.

The 60% number is the felt ubiquity: AI is present in roughly two-thirds of working sessions. The 0 to 20% is the honest measurement of full delegation. “I gave the agent the task and the result was correct without intervention” is rare. Between the two numbers sits the actual job. You start a task in one mode, switch to another when something feels wrong, then switch back when the trajectory stabilizes. Naming the gap is half the work. Naming the cues that fire inside it is the other half, and is the machine-side counterpart of this decision once it has been deferred too long.

The cost of the gap is measurable on the delegation-past-threshold side. CodeRabbit’s December 2025 analysis of 470 open-source PRs (320 AI-co-authored, 150 human-only) found AI-co-authored PRs produce 1.7x more issues per PR (10.83 vs 6.45) (CodeRabbit, 2025). Logic defects up 75%. Security findings 2.74x higher. Performance issues 8x. Critical-severity issues up 40%. The rework is real and measurable; that is the visible cost of delegating past threshold.

The invisible inverse lives on the other side of the gap. METR’s randomized controlled trial put 16 experienced open-source contributors on 246 tasks across repositories averaging 22,000 stars and 1 million lines of code. Developers predicted a 24% speedup. They believed afterwards that AI had sped them up by 20%. The measurement: a 19% slowdown, 95% CI +2% to +39% (METR, 2025). The cost of staying in pair mode when delegation would have shipped is invisible to the developer experiencing it. Google’s DORA 2025 report makes the systemic frame explicit: 90% adoption, 80% report productivity gains, but AI “continues to have a negative relationship with software delivery stability” (DORA, 2025). AI amplifies existing strengths and weaknesses. Teams that delegate poorly delegate more poorly with AI.

The argument states cleanly. The gap is the discipline. It will not close by waiting for better models. It closes by giving practitioners a per-task decision framework, observable inside the session, before the PR exists. The four cues in the section below are that framework.

Citation capsule: Anthropic’s 2026 Agentic Coding Trends Report measures the delegation gap directly. Developers use AI in 60% of their work but can fully delegate only 0 to 20% of tasks; the 40-to-60-point gap is where the practitioner discipline lives (Anthropic, 2026). CodeRabbit’s December 2025 study quantifies the visible cost of crossing the gap: AI-co-authored PRs produce 1.7x more issues than human-only PRs.

Why is “Do I trust the agent?” the wrong question?

The framing was correct in 2024 and is stale by mid-2026. Trust is a property of the tool. Confidence is a property of this task, in this session, with this much information so far. The practitioner question has shifted from “should I use AI?” (resolved: 90% adoption per DORA 2025) to “when, in this session, do I take the keyboard back?” Tool-level trust does not answer that. Task-level confidence does, and it is the operational frame for the rest of mid-2026.

Trust has decayed, but the decay is not the operational story. Stack Overflow’s 2025 Developer Survey (49,009 responses from 166 countries) found trust in AI accuracy fell from 40% to 29% year over year (Stack Overflow, 2025). Only 3.1% highly trust AI accuracy. 45.7% actively distrust it. Experienced developers (10+ years): 2.5% highly trust, 20.7% highly distrust. The trust-decay reading would predict adoption falls. Adoption rose to 90%. Developers have internalized that trust is the wrong axis. They are using AI constantly while trusting it less, which is the calibration response to a tool whose competence is task-dependent.

The 66% number frames the rest of the post. Stack Overflow 2025 found 66% of developers cite “AI solutions that are almost right, but not quite” as their single biggest AI frustration (Stack Overflow, 2025). The “almost right” moment is the title premise rendered as a data point: two-thirds of working developers are regularly experiencing the moment when they should have reclaimed the keyboard. The framework has to be about that moment, not about general trust. Steve Yegge said it as a warning: “if you have any doubt whatsoever, then you can’t use it.” He did not name what doubt looks like in real time. Ethan Mollick’s delegation model includes a P(success) variable but estimates it once, pre-task, then never updates it as the agent runs (Mollick, 2025). The field knows doubt is the signal. The field has not named the signature of doubt during execution.

Replace “do I trust this tool?” with “is my confidence in this task’s trajectory holding or widening?” That single substitution does most of the work. It moves the decision from binary to calibrated, from pre-task to mid-task, from tool to trajectory. It is the same shift the delegation framing needs in order to operationalize. The four cues in the next section are the answer to “what does widening look like, observably, before the PR exists?”

Citation capsule: Stack Overflow’s 2025 Developer Survey, fielded May to June 2025 with 49,009 responses across 166 countries, found trust in AI accuracy fell from 40% to 29% year over year while AI adoption rose. 66% of developers cite “AI solutions that are almost right, but not quite” as their biggest frustration: the felt moment they should have reclaimed the keyboard (Stack Overflow, 2025).

How do you frame the decision as a confidence interval?

The handoff decision is calibrated, not binary. It is a confidence interval, not a trust call. The interval starts wide at task-start (low information, the agent has demonstrated nothing yet), narrows as the agent demonstrates competence on this specific task, and widens when a cue fires. When the interval widens past your tolerance, you reclaim the keyboard. This is the durable framing for the rest of mid-2026, and it is what the four cues are measuring, indirectly but observably.

Why “interval” rather than “trust”? A point estimate of trust forces a binary: trust or do not. An interval forces a question: how wide is it, and is it widening or narrowing? The interval shape matches how working developers actually feel during a session. Confidence at task start is low. Confidence rises as the agent gets early steps right. Confidence drops sharply when an output looks almost right but not quite. The mathematical metaphor is not the point. The shape is. Calibrated and dynamic, not binary and stable.

The empirical floor is in Anthropic’s autonomy data. The “Measuring AI Agent Autonomy in Practice” study of 500,000 interactive Claude Code sessions found that on complex tasks, Claude asks for clarification more than twice as often as humans interrupt it (16.4% vs 7.1% of turns) (Anthropic, 2026). The agent signals uncertainty more often than the human catches it. Most handoff moments are agent-initiated, not human-caught. The signal is already there. The framework is for catching it.

The empirical shape of good calibration is also in the same study. Experienced Claude Code users interrupt more (9% of turns) than new users (5% of turns), yet experienced users also increase full auto-approve from roughly 20% (fewer than 50 sessions) to over 40% (750+ sessions). The pattern: let more run autonomously, but step in faster when something signals wrongness. That is the interval narrowing on familiar shapes and widening on unfamiliar ones. Average human interventions per session fell from 5.4 (August 2025) to 3.3 (December 2025) as the internal task success rate doubled over the same period. The interval gets narrower, faster, with practice. Calibration is a learnable skill, which is exactly the shape the four cues are designed to produce: observable signals, named so they can be practiced, and structured so they can run as evals on session state.

Citation capsule: Anthropic’s “Measuring AI Agent Autonomy in Practice” analyzed 500,000 interactive Claude Code sessions and found that on complex tasks Claude asks for clarification more than twice as often as humans interrupt it (16.4% vs 7.1% of turns). Most handoff moments are agent-initiated, not human-caught; the signal is already there, and the framework is for catching it (Anthropic, 2026).

What are the four cues for taking the keyboard back?

Four named cues tell you when the confidence interval has widened past your tolerance. Each cue is observable inside the session (no separate model call required). Each fires before the PR exists. The four are confidence drift, scope creep, novel error class, and the 80% milestone. One cue is a flag. Two cues together is a strong signal to reclaim the keyboard. Three cues is recovery, not handoff; the delegation already failed and the trajectory needs human direction.

I run this framework on my own work. On Pylon (a PR review pipeline I maintain), the most frequent fire is Cue 2: scope creep. A reviewer agent correctly localizes a regression in a session-management call site, then starts editing the type definition two modules upstream because it has a tidier name. The fix is in the call site. Re-scoping after the second out-of-path file costs about 90 seconds. Letting it run without a named cue cost me an hour the time before I had one. The cues are not new behavior; they are names for the moments practitioners already act on, made consistent enough to share.

Cue 1: Confidence drift

The signature: the agent’s output vocabulary shifts from confident assertions (“I will implement”, “the function now returns”) to hedged ones (“attempting”, “let me try”, “this might work”). The shift is detectable in real time without parsing model internals. It shows up in the running transcript. Why it fires: when the agent’s running estimate of task success drops, the linguistic surface tells you before the output does. Mollick’s pre-task P(success) variable becomes a running signal in this framing, updated continuously rather than fixed at task-start. Response: re-read the plan. Ask the agent to summarize what it believes the task is and where it is in execution. If the summary diverges from your understanding, reclaim.

Cue 2: Scope creep

The signature: the agent is touching files outside the planner’s stated scope, or making changes that imply a different mental model of the task than the one you started with. Why it fires: agentic PRs touch a median of 48 lines vs 24 for human PRs (2x), and 45.05% of agentic PRs require revision (arXiv 2509.14745, 2025). Scope expansion is the leading indicator of “almost right” output. The deeper empirical backing comes from a study of 9,374 trajectories across 19 agents: of 12 never-solved simple-patch tasks, agents correctly localized the bug in all 12 but patched the wrong architectural layer in 10 of 12 (83%) (arXiv 2604.02547, 2026). The agent confidently edits the wrong thing while correctly understanding what is wrong. Response: pause the agent. Have it list every file touched in the last N tool calls. If anything is outside the planner’s path set, reclaim and re-scope. Scope creep is a context-boundary failure in operational form.

Cue 3: Novel error class

The signature: an error signature the agent has not handled in this session, or that you have not seen in this codebase before. Repeated familiar errors (a test the agent has seen and fixed before) are safe to delegate. First-occurrence unfamiliar errors are not. Why it fires: novel errors are the precise point where the agent’s training distribution is most likely to be insufficient and where human judgment provides the most value. The same arXiv 2604.02547 study found agents that gathered context before editing succeeded more (rho = +0.68, p < 0.001) and agents that front-loaded patching failed more (rho = -0.78, p < 0.001) (arXiv 2604.02547, 2026). The novel-error response is “stop, look at the error class, decide whether to investigate together,” not “let the agent guess again.”

Cue 4: The 80% milestone

The signature: the primary deliverable is present and compiling, but edge cases, integration boundaries, and verification steps remain. Addy Osmani named the 80% problem as a quality observation (Osmani, 2026). This framework operationalizes it as a real-time trigger. Why it fires: the 80% milestone is structurally the right moment to reclaim for the verification, edge-case review, and integration decisions that require ownership. Kent Beck’s “watched intermediate results and intervened with specific direction” framing is the empirical kernel (Beck, 2025). Response: reclaim. The agent’s job is done. Yours is starting.

The four cues running as a small decision script in your hooks layer:

def confidence_drift(transcript_window) -> bool:
    hedges = ("attempting", "trying", "might", "perhaps", "not sure")
    asserts = ("implementing", "returns", "passes", "added")
    last = transcript_window[-200:].lower()
    return last.count_any(hedges) > last.count_any(asserts)

def scope_creep(touched_paths, planner_scope) -> bool:
    out_of_scope = [p for p in touched_paths if not within(p, planner_scope)]
    return len(out_of_scope) >= 2

def novel_error_class(error_history) -> bool:
    if not error_history: return False
    return error_history[-1].signature not in {e.signature for e in error_history[:-1]}

def eighty_percent_milestone(progress) -> bool:
    return progress.primary_deliverable_compiles and not progress.edges_verified

def should_reclaim_keyboard(cues: list[bool]) -> str:
    n = sum(cues)
    if n >= 3: return "recover"
    if n == 2: return "reclaim"
    if n == 1: return "flag"
    return "continue"

The four cues are evals running on session state, the same shape agent eval primitives take in offline scoring; the difference is the loop closes inside the session instead of at the PR.

Interpretation matters as much as detection. One cue is a flag; check the plan, ask a clarifying question, keep the agent running. Two cues together is a strong signal to reclaim. Three cues is recovery, not handoff; the delegation already failed and the trajectory needs human direction. The aggregator is intentionally simple, because the cues themselves carry the information.

Citation capsule: The four named cues for keyboard reclaim are confidence drift, scope creep, novel error class, and the 80% milestone. The empirical anchor is arXiv 2604.02547’s finding that across 12 never-solved simple-patch tasks, agents correctly localized the bug in all 12 but patched the wrong architectural layer in 10 of 12 (83%) (arXiv 2604.02547, 2026). The agent confidently edits the wrong thing while correctly understanding what is wrong; scope creep is that failure compressed into a single task.

Why are pair and delegate operating modes, not task assignments?

Every existing taxonomy treats pair-vs-delegate as a property of the task assigned (Swarmia’s five-level model, Bessemer’s six-level scale, Osmani’s conductor-vs-orchestrator framing, Gene Kim’s four-tier pre-task delegation criteria). The choice is made once and held. This post inverts: same task, same agent, same session; mode is what the human is doing right now. Mode is a response to cues, not a project-level decision. Mode switches mid-task when a cue fires.

Mode-as-moment, not mode-as-assignment. You can start a task in delegate mode (the agent has autonomy to take 10 steps without check-in), receive a confidence-drift signal at step 4, and switch to pair mode (each step is reviewed before the next) for steps 5 through 8. At step 9 you can switch back. The switch is the response to the cue, not a re-assignment of the task. The empirical backing is in Anthropic’s autonomy study: top reasons users interrupt agents include 32% to provide missing context, 17% to address slow or hanging processes, and 7% to proceed independently or take the next step themselves (Anthropic, 2026). These are all mid-task mode switches. The developer is not abandoning the agent; they are dropping into pair mode briefly to provide context, unstick a step, or do one operation themselves.

Four operating modes resolve the moment-to-moment choice without inventing new vocabulary:

• Delegate. The agent runs autonomously across multiple steps. The human checks in at planned milestones or on agent-initiated signals. This is the default for low-risk, well-specified work.
• Pair. Each step is reviewed before the next. The human is steering in real time. This is the response to confidence drift or novel error class.
• Observe. The agent runs, but the human is watching the transcript actively. No action yet, but the cues are being tracked. This is the holding pattern between delegate and pair when one cue has fired but more information is needed.
• Reclaim. The human takes the keyboard back and the agent waits or assists. This is the response to two-or-more cues, the 80% milestone, or scope creep that exceeds the planner’s path set.

The asymmetry is operational, not theoretical. Delegating into pair mode is cheap (you just start reviewing). Reclaiming is more expensive (you need to understand what the agent has done, where it is, and what is salvageable). Justin Searls’ “agents are bad pair programmers” framing makes the speed-mismatch case directly: agents code faster than humans think, humans disengage and lose oversight (Searls, 2025). The response is not to avoid pair mode but to enter it with intent when a cue fires. Spawn-vs-stay is the macro version of the same decision applied to the agent’s own future; mode-switching mid-task is the within-task application.

Citation capsule: Anthropic’s autonomy study identifies the top reasons users interrupt agents in production Claude Code sessions: 32% provide missing context, 17% address slow or hanging processes, 7% proceed independently or take the next step themselves (Anthropic, 2026). Each is a mid-task mode switch, not a re-assignment; pair and delegate are operating modes the developer enters and exits as cues fire.

Why is selective escalation a learned skill?

The most counter-intuitive finding in Anthropic’s 2026 autonomy study is that experienced users interrupt agents more often than new users (9% of turns vs 5%) while simultaneously auto-approving more often (over 40% at 750+ sessions vs roughly 20% under 50 sessions) (Anthropic, 2026). This is selective escalation: let more run autonomously, but step in faster and more precisely when something signals wrongness. It is the empirical shape of good calibration, and it is a skill that improves with practice.

The pattern is the inverse of what most adoption narratives predict. The intuitive story: experienced users learn to trust the agent and interrupt less. The data says the opposite. Experienced users delegate more and interrupt more, on different things. The skill is not “more delegation” or “less”; it is “knowing which moments are which.” The four cues above are the substrate of the skill; the modes are the response set; selective escalation is what emerges when both become habit.

The 5.4-to-3.3 trajectory carries the improvement curve. Average human interventions per Claude Code session fell from 5.4 (August 2025) to 3.3 (December 2025) as the internal task success rate doubled over the same period (Anthropic, 2026). Practitioners are getting better at not interrupting unnecessarily. Simultaneously, the 99.9th percentile turn duration nearly doubled from under 25 minutes to over 45 minutes. People are letting agents run longer when the cues say to. Practice cycles of roughly 50 sessions are visible in the data as inflection points; the skill is acquirable on the order of weeks, not years.

The decay risk is real but is also misread. Stack Overflow 2025 found trust in AI accuracy falling sharper among experienced developers (2.5% high trust vs 3.1% overall) (Stack Overflow, 2025). The skill is not naive optimism. It is calibrated skepticism. Experienced users delegate more and trust less, simultaneously, because they have a framework for when to look. The cost of not learning is visible at the team level. Faros AI’s December 2025 telemetry across 22,000 developers and 4,000 teams found production incidents per PR up 242.7%, median PR review time up 441%, and 31.3% more PRs merging with no review at all (Faros AI, 2025). Tasks completed up 33.7%, epics up 66.2%, but deployments down 11.7%. This is the systemic shape of over-delegation: more throughput, more incidents, less review. Selective escalation is the team-level cure, and the PR review layer is where the in-session decision turns into a team-scale gate.

The practice loop is the takeaway. The four cues are the substrate. The modes are the response set. Selective escalation is what emerges when both become habit. The skill is acquirable in weeks, and the data says the acquirers are simultaneously delegating more and interrupting more, on different things.

Citation capsule: Anthropic’s Measuring AI Agent Autonomy in Practice found experienced Claude Code users interrupt 9% of turns versus 5% for new users, while full auto-approve rises from roughly 20% at fewer than 50 sessions to over 40% at 750+ sessions. Average human interventions per session fell from 5.4 in August 2025 to 3.3 in December 2025 as the internal task success rate doubled (Anthropic, 2026).

Is the real question readiness or governance?

“Agents are not ready for autonomous coding” was the right framing in 2024 and is the wrong framing by mid-2026. Agents are already in production at Goldman Sachs (CNBC, July 2025), shipping PRs at 90% adoption per DORA 2025, and running for roughly 25 uninterrupted hours on demo workloads (OpenAI, 2026). The question is not whether autonomous coding is happening. It is how to govern the control transfer during it.

The stale framing predicts the practitioner question dissolves as capabilities improve. The data says otherwise. METR’s January 2026 Time Horizon 1.1 report found post-2023 cohort doubling time of 131 days (roughly 4.3 months) with the benchmark suite near saturation above 16 hours (METR, 2026). Capability moves on a four-month clock. The discipline has to move with it, not wait for it. Waiting for better models is the loudest anti-trend; it has been wrong on every doubling for two years and is unlikely to start being right now.

The governance frame replaces the readiness frame. The handoff decision is no longer about whether to delegate (most tasks are getting partial AI involvement regardless). It is about who owns the decision to reclaim, when, and under what cues. At the individual level, the four cues are the framework. At the team level, the question becomes: which PRs require human review, which can be reviewed agent-to-agent, and who decides? That is the team-scale generalization the field has not yet resolved. The 90% adoption number makes the readiness question moot. The 0 to 20% full-delegation number makes the governance question urgent.

The arc closes here. The companion post, Long-Running Autonomous Agents, covers what happens when no decision fires: drift over hours, trajectory failure, recovery cost. This post covers the decision that precedes drift. The two are a pair, decision-then-consequence. The same engineering discipline shows up twice, at the human layer and at the machine layer.

Citation capsule: The framing “agents are not ready” was correct in 2024 and is stale by mid-2026. Goldman Sachs deployed Devin at scale in July 2025 (CNBC, 2025). DORA 2025 measured 90% AI adoption (DORA, 2025). The question shifted from readiness to governance: who owns the reclaim decision, when, and under what cues?

FAQ

How do I know if I am drifting toward over-delegation?

Three signals. First, you have not interrupted in this session and the task is taking longer than expected; that is delegation by default, not by decision. Second, you cannot summarize what the agent has changed in the last 10 minutes without re-reading the transcript; the audit trail is in your head, not yours. Third, the output is “almost right but not quite”; the 66% Stack Overflow frustration is the moment (Stack Overflow, 2025). If any two of those are true, you have over-delegated. Reclaim and re-scope.

What is the difference between confidence drift and a hallucination?

A hallucination is a wrong fact at one step (the agent invents an API that does not exist). Confidence drift is a behavioral signal across the agent’s running output: vocabulary shifts from confident to hedged, plans get re-stated with smaller scope, the agent starts asking clarifying questions where it was previously asserting. Hallucinations are caught by tests. Confidence drift is caught by reading the transcript. Different failure modes, different signals, different responses.

Should I reclaim the keyboard at every novel error?

No. Reclaim when the novel error is in an area where your judgment is materially better than the agent’s, which is usually true for first-occurrence errors in unfamiliar codebase regions, third-party API failures not in training data, and type errors with runtime-state dependencies. For familiar errors (test failures the agent has seen and fixed before), let the agent try. The cue is “novel error in this session,” not “any error.” arXiv 2604.02547’s wrong-layer patching finding (83% on never-solved simple patches) is the empirical backing (arXiv 2604.02547, 2026).

When should I just restart instead of taking the keyboard back?

Restart when the original task was mis-specified at session start; nothing in the trajectory is salvageable. Reclaim when the task is correctly specified but the agent’s trajectory has drifted; the intermediate work has audit value or partial-progress value. The companion post on long-running agents covers the fork-not-restart pattern for the machine-side recovery. The human-side decision is the same shape: preserve the trajectory as audit, branch into corrected execution, do not throw away work the agent has already done correctly.

Conclusion

The delegation gap is the discipline. 60% AI involvement, 0 to 20% full delegation, and the 40-to-60-point gap between them is where every working developer in 2026 lives (Anthropic, 2026). The framing shifted. Trust is a property of the tool. Confidence is a property of this task. The decision is a per-task interval, not a per-tool binary. Four named cues tell you when the interval has widened past your tolerance: confidence drift, scope creep, novel error class, and the 80% milestone. One is a flag. Two is a reclaim. Three is recovery. Pair and delegate are operating modes, not task assignments; the mode is what you are doing right now and switches mid-task when a cue fires. Selective escalation is a learned skill. Experienced Claude Code users interrupt more (9% of turns) and auto-approve more (over 40% at 750+ sessions) simultaneously, on different moments (Anthropic, 2026). The autonomy arc reads as decision-then-consequence. This post is the human-side decision layer. Long-Running Autonomous Agents is the machine-side consequence layer when no decision fires.

Name one cue you will watch for in the next session. Confidence drift is the cheapest, no tooling required. Commit to interrupting on it once. Calibrate from there. The handoff is a habit, not a heroics moment; the discipline is in naming the cue out loud before the keyboard is yours again.