TL;DR: Addy Osmani’s reminder: no matter how many agents you run in parallel, there’s still only one pair of eyes on the outputs. The better the model, the fewer obvious errors, and the easier it becomes to slide from “handing over work” to “handing over judgment.” Reminding yourself to check more often isn’t enough. Once output volume climbs, that reminder is the first thing that gets skipped. Drawing on false-green-light moments from my own work, I’ve distilled three workflow-level mechanisms: success signals that can say “unknown,” reviewers who don’t know your conclusion, and completion criteria written before work starts.

On August 9th, the git health-check I run before pushing to my mirror repository failed three times in a row. Its job was to detect version divergence across several mirrors. Each time, it reported “no divergence.” One mirror was actually three commits behind, including a security patch. The check had crashed before its detection phase completed, then dutifully printed a hardcoded success string for a conclusion it had never verified. I wrote about this in AI Patrols My System Every Day, Until the Gatekeeper Itself Breaks.

Three months later, I read Addy Osmani’s Critical thinking when agents do the work. His X bio says he works on Claude Code at Anthropic; this piece reflects his personal views. He’s a heavy agent user himself, and he’s clear the article isn’t an argument for using fewer agents. What brought those three “no divergence” reports back to mind was the opening line: no matter how many agents you run simultaneously, “you still only have one pair of eyes on the outputs.”

Offloading, Deferral, Surrender: What Is the Three-Stage Spectrum?

Addy arranges the human-AI relationship along a single spectrum.

At one end is cognitive offloading: you hand the work to an AI, but you remain responsible for the result. He says he does this all day and recommends it. In the middle is deferral: the tool’s output flows directly into your next step, no longer treated as a hypothesis waiting to be tested. At the far end is cognitive surrender: the AI’s answer has quietly become your conclusion, and you no longer feel any need to check.

“Cognitive surrender” isn’t Addy’s coinage. It comes from a paper by Wharton’s Steven Shaw and Gideon Nave, written in January of this year: Thinking — Fast, Slow, and Artificial. They extend Kahneman’s intuitive System 1 and deliberate System 2 by treating AI as an external “System 3,” then separate two modes of use: offloading is strategic delegation within the thinking process, while surrender means bypassing deliberation and adopting AI output with almost no verification.

They ran three controlled experiments using an adapted Cognitive Reflection Test, with 1,372 participants and 9,593 responses in total, secretly controlling when the AI answered correctly and when it did not. In the first experiment, compared to a no-AI baseline, participants receiving a correct AI answer scored about 25 percentage points higher. Those receiving a wrong AI answer scored about 15 percentage points lower. Confidence rose in both cases.

Key Numbers

  • Study scale: 3 pre-registered experiments, 1,372 participants, 9,593 responses (Shaw & Nave, 2026)
  • AI answered correctly: In the first experiment, accuracy was about 25 percentage points above baseline
  • AI answered incorrectly: In the same experiment, accuracy was about 15 percentage points below baseline, with confidence still rising

Addy describes the slide as gradual: you read the first answer carefully, skim the second, glance only at the structure of the third. Then someone asks what a particular line does, and you can’t explain it.

Four-panel comic: Why Does a Better Model Make It Easier to Hand Over Judgment? Handing work to AI while remaining responsible for results. Tool output flows directly into the next step, no longer treated as a hypothesis requiring verification. AI's answer quietly becomes your conclusion, and you no longer feel you need to check. When completed work piles up faster than you can read it, opening another session doesn't help. When output exceeds what you can vouch for, you're no longer reviewing. You're just hoping.

Why Does a Better Model Make It Easier to Hand Over Judgment?

The intuitive assumption is that a more accurate AI requires less supervision. Addy’s observation runs the other way. As models improve, the proportion of obvious errors shrinks. Most output reads well and is roughly correct, so people stop taking a second look. Errors become rarer, but they don’t vanish. The ones that remain find it far easier to pass through undetected.

Anthropic’s own research runs into the same thing. In August 2025, they surveyed 132 engineers and researchers. Some worried that deeper technical skills would atrophy. The research page called it the “oversight paradox”: using Claude well requires overseeing it, and the coding ability needed to oversee it is precisely what erodes through over-reliance on AI. An internal employment study from October of this year put it more directly: as agent output accelerates, human attention becomes the bottleneck. Even non-technical employees would need half a working week just to fully read everything their agents produced.

That lands differently when you’re one person running several agents. You can open another agent. You can’t grow another pair of eyes.

What Does a Green Light Actually Prove?

Addy’s verification principle is two sentences: when the green light turns on, ask what it proves. Then ask what it doesn’t prove.

Looking back at my own records, I’ve hit the same question twice.

The first time was the health-check at the opening of this piece. Its green light proved only that “a line of text was printed.” It did not prove that “divergence was actually checked.” The process had crashed before detection was complete.

The second time was when I asked Codex to review a tool written by Claude (described in Getting AI to Spot AI’s Mistakes). My original acceptance condition was “the final message is not blank.” That would catch the case of a process exiting without leaving any text, but it couldn’t confirm that the text had read the right target or covered the intended scope.

Both times, I had let a hardcoded success string answer a question it had never actually asked. That’s deferral: the tool’s output flowing directly into the next step.

This Draft Almost Did the Same Thing

The first draft of this article was written by Claude. I gave it notes compiled by another AI from Addy’s piece, which mentioned “a weekly calibration exercise” and the question “how lost would you be without AI?” Claude then asked Perplexity to retrieve the original text.

The passages Perplexity returned did not contain either phrase. Claude accordingly wrote a paragraph in the draft: two lines in the notes had no traceable source, and two AIs corroborating each other does not constitute going back to the original.

When reviewing, Antigravity flagged that paragraph for revision. If the author had only seen the passages search had indexed, “not found” couldn’t serve as a conclusion. Claude searched again. Both phrases were there, in the “daily practices” section near the end.

Addy’s piece had anticipated exactly this: each agent passes a summary of the previous agent’s summary along the chain, and by the third agent, no one has read the original document.

What got caught wasn’t the notes. It was the drafting pass. Given half the source material, that pass drew a conclusion for the whole piece, one that happened to fit the article’s theme and read cleanly. The drafting agent didn’t catch it. What stopped it was a reviewer who didn’t already know the conclusion.

Why Isn’t Reminding Yourself to Check More Often Enough?

Addy’s article includes a long series of self-directed questions: Did I form a hypothesis before asking? What would have to be true for this answer to be wrong? Would I be willing to bet on this in front of someone who maintains the code? All good questions. I work through them too.

The problem is that they all depend on willpower. The premise of this whole discussion is that agents keep multiplying while attention stays fixed. The more output accumulates, the sooner self-initiated checking gets dropped. In the health-check incident, the Codex review, and the drafting of this article, I knew in each case that checking was necessary. What I lacked was anything that forced it to happen in that moment.

Addy points toward a solution. He mentions having Claude Code use a fresh-context sub-agent to check its own work, and says that step is worth building into the workflow so it runs every time, not just when you happen to think of it.

He also addresses output volume. He calls the gap between what agents produce and what you’re willing to put your name on the “orchestration tax.” When completed work accumulates faster than you can read it, opening another session solves nothing. Tighten the checking first, so less output requires your direct attention, or slow down. When output exceeds what you can vouch for, he says, you’re no longer reviewing. You’re just hoping. Another approach appears in the same piece: when something falls short, write the reason into a shared config, hook, or test, so the same thing can’t happen again.

So I turned the self-questions into mechanisms. The three below are ones I already use.

Three Mechanisms to Build Into Your Workflow

First: success signals must be able to say “unknown.” After the health-check incident, I changed the output string to “divergence status unknown (detection incomplete)” and left a note beside it: the wording must not revert to “no divergence.” Whether divergence exists is unknown, not ruled out. If the check didn’t finish, the result is unknown. A hardcoded success string can’t substitute for that. No one has to remember to ask what wasn’t checked. The signal says it itself.

Second: reviewers must not know your conclusion. When I ask Codex, Grok, and Antigravity to review something, I give them only the target and the criteria. I don’t tell them I think it’s fine. (The approach is described in Before You Let AI Tackle Bigger Things, Build the Error-Catching Infrastructure.) Acceptance conditions are also split apart: program produced output, ran to completion, and passed review are three separate conditions. That’s how the error in this article’s draft was caught. The same applies to humans. When you ask a colleague to look at something, don’t tell them you think it’s fine first.

Third: completion criteria must be written before work begins. Addy’s formulation: define what “verified” means in advance, because afterward you’ll rationalize any result. The finish line should be something visible, like tests passing, a screenshot, or a log entry. My site’s deployment script records success only when five conditions all hold: the deployment command succeeded; the live production ID is readable after deployment; that ID matches this deployment; the post-deployment automated checks ran completely and all passed; and after those checks finish, the production ID is read once more and still matches. If any step fails to return a result, success is not recorded.

These three mechanisms share one property: none of them require me to stay vigilant at the moment I’m tired or in a hurry.

Mechanisms Break Too

I don’t want to present this as a cure-all. The AI Patrols My System Every Day piece is about exactly this: the gatekeeper itself breaking down. Build a mechanism well enough, and it becomes the new green light.

That’s why, alongside the mechanisms, some time must remain for a human to review the mechanisms themselves. Addy offers two standing practices: once a week, do something without agents, specifically the kind of thing where forgetting how would be costly; once a month, write down what you’ve stopped doing yourself, then decide which of those you can legitimately let go. He also returns to a question from an older piece of his: how lost would you be if AI weren’t available?

That One Pair of Eyes

Addy writes in the piece: work can be offloaded, most checking can be offloaded, but responsibility cannot.

You can keep adding agents. The eyes stay one pair. Since they’re not enough to cover everything, mark out what they most need to see: which signal should report “unknown,” which review wasn’t steered by your conclusion beforehand, which “complete” was defined before work began.

This article sits under Human-AI Collaboration within AI and Human Order. The next time you see the word “complete,” the first question to ask is what was checked, and what wasn’t.

Sources

All links verified November 6, 2026. Addy’s original X post was opened in full in a browser that day and checked sentence by sentence.