Skip navigation

FreeArticle

Cognitive surrender: keeping your judgment when agents do the work

When should you check an agent's output closely, how do you check the evidence, and which judgment stays yours? An analysis of Addy Osmani's take on cognitive surrender and accountability when you delegate.

15 min read · v1.0.0 · Updated 04/11/2026

VI · Cognitive surrender: giữ tư duy phản biện khi giao việc cho agent · Read in Vietnamese

Quick summary: Cognitive surrender is when you take an AI's output as your own conclusion and no longer feel the need to check it. Avoiding it does not mean reading every line an agent writes. Instead, make a prediction before you ask, decide what evidence you need, and check that evidence before you read the summary. For decisions that can hurt other people, the judgment still has to be yours.

In Critical thinking when agents do the work, Addy Osmani looks at a problem everyone who uses agents daily runs into: the more polished the output and the fewer the obvious mistakes, the more tempting it is to skim. He is in favor of working with agents and does not suggest using them less. What he wants to protect is the judgment of the person handing out the work.

I read his piece through two questions: when do you need to check closely, and how do you check so that you have real grounds to accept the result. I keep Addy's views apart from my own comments throughout. I start by separating what you can fully hand to an agent from what you still need to weigh yourself.

Four-step sketchnote from left to right: a person writes down a prediction and states their intent, an agent does the work, the person inspects the evidence and the agent's decisions with a magnifying glass, then signs off on the result
The agent does the middle. You keep both ends: a prediction and clear intent before you ask, evidence and decisions after the agent reports done.

When do you need to keep the reasoning?

According to Addy, you can fully delegate decisions where being wrong costs little. He describes asking an AI to pick one of three similarly rated hotels for a course shoot, and says he would do it again. But for questions like what to build, who a change will affect, or whether something is safe to ship, he keeps the judgment.

A three-step slope. The top step reads cognitive offloading, where a person stands steady holding a checklist. The middle step reads deferral, where the person stacks blocks on a block with a question mark. The bottom step reads cognitive surrender, where the person leans back without looking at the card the agent hands over. A dashed arrow reads sliding down
People slide from offloading down to surrender one step at a time, and every step looks reasonable.

The same person can delegate sensibly in one situation and give up their judgment in another. Addy describes three levels of delegation:

LevelWhat is happeningHow to recognize it
Cognitive offloadingThe agent does the work, and you still own the result.You know what you are accepting the result on, and you can explain it when asked.
DeferralYou use the tool's output as the basis for your next step and no longer treat it as a hypothesis to test.You keep building on an earlier answer you have not checked.
Cognitive surrenderThe AI's output gradually becomes your own conclusion.You feel no need to check, or you cannot explain the result even with the agent's help.

The middle level is the easiest to miss. Say an agent guesses the cause of a bug and you immediately ask it to fix that cause. The work moves forward, but a hypothesis has been treated as a fact.

In my view, the value of this split is that it changes the question from "should I trust AI?" to "for this task, how much am I handing over?". You need to check more closely when a mistake has real consequences, when you cannot explain a decision, or when you do not know what your existing checks miss.

Being able to explain the result and being willing to own it are two practical self-checks. I do not think they are enough, though. You can explain something very clearly and still be wrong. So the explanation still has to be checked against evidence.

What do you keep before you ask the agent?

Addy argues that human thinking is moving to the two ends of the work: framing the problem and judging the result. When a request is vague, an agent fills in the missing assumptions and produces something that looks finished. A colleague would usually come back with a question.

He calls the goals, constraints and reasons that were never stated intent debt, in his own piece republished on O'Reilly Radar. An agent can help you sharpen a request, but you still decide the goal and the constraints that matter.

Before a substantial task, Addy suggests writing the request in your own words: who the work is for, what is out of scope, and what counts as done. In his experience, if a second round of corrections still has not got you there, consider rewriting the request instead of patching details. Treat this as a cue to rethink how the problem is framed, not a hard limit. A hard debugging session can still need many rounds.

Addy offers six questions for checking your own judgment:

  • Did I have a hypothesis before I asked? Being wrong is fine. According to Addy, a convincing answer can make it hard to think of alternatives, so form your own guess before you read the reply.
  • Do I want the agent to help me think, or to think for me? Both have their place, as long as you know which one you chose.
  • What, if true, would make this conclusion wrong? Look for a real test of that possibility. According to Addy, a test you can run beats the confidence a model reports about itself.
  • Have I looked at the counterargument? Addy asks several models to argue the other side, then draws his own conclusion.
  • Would I defend this result to the person who has to maintain it? Ask whether you could explain what you hand over and answer questions about it.
  • Which skill am I practicing less? You may be fine no longer doing some things by hand, but that should be a deliberate choice.

If you do not know where to start, you can ask the agent to question you until the request is clear. Addy links this kind of collaboration to Andy Clark's Extending Minds with Generative AI (Nature Communications, 2025): turn by turn, you get clearer on what you think and what you want. Another option is the blind spot pass that Thariq Shihipar describes. You give the AI what you already know, then ask it to find the important questions you have not thought of.

When the agent reports done, what do you check first?

According to Addy, the bottleneck is moving from producing a result to having enough grounds to believe it is right. You do not have to read every line of code. What matters more is setting up a way to check and then looking at the evidence it produces.

A person shines a flashlight on a sketch of an app. The light covers only the user interface and reads what the check covers. In the dark area sit a database labelled data saved and a warning sign labelled error handling, and the whole area reads not checked
A check only proves what it covers. A correct screenshot of the UI says nothing about saved data or error handling.

Boris Cherny put the principle this way in a post on January 2, 2026: "give Claude a way to verify its work". With a way to check, such as end-to-end tests or driving the app directly, the agent can fix, run tests, read errors and retry before you look at the result.

Still, the checking itself can be over-delegated. At first you ask "is there evidence?", and over time you only look at whether the tests are green. If the tests and the implementation share the same misreading of the request, both can be wrong while the tests still pass.

From Addy's suggestions, three things to do when you check a result:

  • Decide up front what counts as checked. Write down the behavior to prove and the evidence you want before the agent finishes. If you set the criteria after you see the result, it is easy to find reasons to accept what you already have.
  • Look at the evidence before the summary. See which commands the agent ran and what they returned. Evidence can be test output, screenshots, logs or execution traces.
  • Ask what the check proves and what it misses. Passing tests only tell you the system does what those tests actually test.

For example, a screenshot shows the UI rendered correctly at the moment it was taken. In my view, that is not enough to conclude the data was saved correctly or that the app handles errors properly. Check what bears directly on the conclusion you are about to accept.

Not every change needs the same depth of checking. How the Claude Code team does code review gives one way to choose: if you cannot say what the checks might miss, ask for a thorough review instead of a quick one. If you can name that limit, the existing checks are usually enough for that change.

The principle applies outside code too. Addy's example is an agent that synthesized fifty customer calls. Before you base a recommendation on it, open a few of the source documents and check the numbers that matter. In my view, this is targeted spot-checking. A few correct samples do not prove the whole synthesis is accurate, but a single wrong one gives you a reason to keep checking.

Read the decisions the agent made

Passing tests do not mean the agent understood the request. You also need to look at the choices the agent made along the way, especially the ones that never show up in its summary.

Addy describes a 600-line pull request (PR). The structure makes sense, the names are clear, the tests pass, so it gets approved. But somewhere in those changes there might be a reordering at a transaction boundary, or a default that changed in an edge case. If you only check for what you already had in mind, those changes are easy to miss.

He suggests reading the diff as if the AI had not written it, then looking past it for the decisions the agent made on its own. Which default did it pick, what did it leave out of scope, how did it reinterpret the request when two requirements conflicted? Ask the agent to list the decisions and assumptions it relied on, then check closely the ones that can have real consequences.

To test whether you really understand the result, Addy suggests picking a few lines of code and trying to explain them. For a document, close it and write down the main argument from memory.

Thariq Shihipar gives a more concrete version in his field guide to finding your unknowns when working with the Claude Fable 5 model. Thariq has Claude write a change report along with a quiz that tests his understanding. His rule: "I only merge after I pass the quiz perfectly". Addy cites this habit as one he likes.

In my view, acing the quiz tells you how well you understand the parts it asks about. But the agent also writes the quiz. If it misread the request in some edge case, the quiz can skip that case too. You answer everything correctly and the bug is still there. In an earlier post, Fable 5 and the unknowns problem, I turned these two practices into two reusable skills, /blindspot and /quiz-gate.

Addy also uses agents to triage PRs in one of his open-source projects, pointing out what needs attention. Even so, he rarely lets the agents decide that on their own. Screening can be handed off so that human time goes to the decisions that matter more.

Is not remembering the whole system a form of surrender?

No. Addy is clear that nobody can hold all of a large codebase in their head. The post on how the Claude Code team does code review also describes asking Claude to explain just the part of the system they need to understand.

The difference is whether you notice what you do not understand and know how to get back the knowledge you are missing. According to Addy, recovering your understanding of part of a system can be easier than many engineers expect, as long as you know what you need to understand.

He mentions two kinds of debt that usually only show when the system has to change. Margaret-Anne Storey writes about cognitive debt, where a team gradually loses its shared understanding of how a system works. For code, Addy writes about comprehension debt: the code looks clean and the tests pass, but when a change is needed nobody understands it well enough to make it.

In my view, this is an important limit on the advice "understand what you ship". You need to understand the part of the system that is changing, your grounds for accepting the result, and what could go wrong. Nobody expects you to remember every detail of the whole system. Asking an agent to explain is reasonable, but you still need to check the explanation against the code or the actual behavior. Otherwise you have only moved from trusting the result to trusting the explanation.

Does a better model make supervision lighter?

You can hand more of the bug-finding to agents, and Addy supports that. But how far to trust an agent is still your call, especially as the ways models fail keep changing. In the end, someone still has to answer for what ships.

The report How AI is transforming work at Anthropic, based on an internal survey and interviews, calls this the paradox of supervision. To supervise Claude, people need the very skills that relying too much on AI can cause them to practice less and slowly lose.

It also helps to separate research evidence from observations from practice. The term cognitive surrender comes from research by Steven Shaw and Gideon Nave at the Wharton School of the University of Pennsylvania (SSRN version). The abstract on Shaw's profile page describes three preregistered studies with 1,372 participants. The studies used an adapted Cognitive Reflection Test, with the AI secretly set to answer correctly or incorrectly.

In the first study, compared with working without AI, accuracy rose by about 25 percentage points when the AI was right and fell by about 15 points when it was wrong. Participants tended to follow the AI's answer in both cases.

Addy's piece is an essay built on experience and observation that connects the research to everyday practice. In my view, his advice as a whole should not be read as a process that has been validated experimentally. Results from a reasoning test are also not enough to conclude that AI has the same effect on engineering work.

When the work outgrows your review capacity

Addy calls the gap between what agents produce and what you would be comfortable putting your name on the orchestration tax. When agents produce results faster than you can review them, the queue of unchecked work keeps growing. Opening another agent session does not clear that bottleneck. He offers two ways out: improve the checks so fewer results need a person to look at them, or deliberately slow down.

Three robots on a conveyor belt push out a tall, wobbly pile of paper. On the right, a person at a desk has a short stack of signed pages. A bracket between the two piles reads orchestration tax, and two signposts read tighten checks and slow down
The orchestration tax is the gap between what agents produce and what you would put your name on. More agent sessions do not close it. Only tighter checks or a slower pace do.

Addy also suggests doing one task by hand each week that you do not want to forget how to do. Each month, write down what you have stopped doing yourself and decide which skills you are fine letting go. He calls it a calibration exercise, not a moral one. He is also clear that you do not need to adopt every suggestion. Knowing when to check closely is a skill in itself.

In my view, you have to budget for checking time too. Even with tools to help, setting up checks and reviewing evidence takes effort. Spend that time on decisions with real consequences and on the skills you do not want to lose yet.

Frequently asked questions

The three questions below help tell sensible delegation apart from giving up your judgment altogether.

Is it wrong to fully hand a decision to an agent?

No. According to Addy, full delegation is reasonable when the cost of a mistake is small enough, such as choosing between a few equivalent options. What matters is that you know you are handing over the decision itself and are ready to live with the outcome.

If the tests pass, do I still need to read every line?

Not necessarily. You need to know what the checks proved, what they missed, and which important decisions the agent made. If you cannot name the limits of the checks, review more closely instead of relying on a green test run.

Is asking the agent to explain the code still thinking for myself?

Yes, if you use the explanation to understand the code in front of you and then check it against the code or the actual behavior. After that, try explaining the decisions yourself and pin down what you still do not understand.

Start with two notes

Addy's closing exercise is simple enough to use the next time you hand out a task:

  • Before you ask: Write down what you predict will happen, even if you are not sure you are right.
  • After the agent finishes: Write down one thing the agent did not check.

The two notes give you a prediction to compare against the answer and at least one known limit of the result. For work where a mistake costs little, you can accept that limit. But if the decision can affect other people, that is exactly where to keep checking. Addy ends on one line: "You may offload the work and much of the auditing, but not the accountability."

Use this piece in your agent

Get an API key

Copy the text below and paste it into Claude Code, Codex or whichever agent you use. The agent reads the piece and checks it against the repo you have open.

Paste into your agent
Read "Cognitive surrender: keeping your judgment when agents do the work" on modernEngineer and apply it to this repo.
1. Call the content_get tool of the modernengineer MCP server with locale "en", slug "critical-thinking-when-agents-work". If MCP is not connected or access is refused, read the page https://modernengineer.dev/en/library/critical-thinking-when-agents-work instead.
2. Summarize the main steps of the piece and point out which apply to this repo.
3. Propose concrete changes and ask me before editing any file.
Connect MCP in Claude Code (once)
terminal
claude mcp add --transport http modernengineer \
  https://api.modernengineer.dev/mcp \
  --header "Authorization: Bearer <API key>"
How to connect Codex, Cursor and other clients

This piece is open to everyone: without MCP, the agent can still read it straight from the link.

Version
v1.0.0
Updated
04/11/2026
Licence
All rights reserved
Slug
critical-thinking-when-agents-work