Three practical strategies to keep real judgment in your coding agent planning sessions, based on Anthropic's research on AI deference.
How do you know if you’re deferring judgment to your coding agent? #
You’re probably deferring more than you think. A recent Anthropic study found that when an AI agent was set up to lean toward one option in a decision, the humans working with it went along with that lean 86% of the time, even though the lean was randomized and had no connection to which answer was actually correct. If the agent’s opinion made no difference, that number should sit around 50%. It didn’t. The gap between those two numbers is the size of the problem.
TL;DR #
- Planning sessions with coding agents often turn into a loop of multiple-choice questions where the agent recommends an answer and you approve it, which feels like judgment but mostly isn’t.
- Anthropic’s study found that people switched away from their own stated position 60% of the time when their agent disagreed with them, versus only 6% when it agreed.
- A striking number of people later described the agent’s reasoning as their own thinking , sometimes repeating it almost word for word, while only a small fraction credited the agent as the source.
- Experience didn’t protect anyone : more seasoned analysts were just as likely to defer to the agent’s lean as less experienced ones.
- The fix isn’t to use AI less. It’s to change when and how you let the agent weigh in, so you form a real opinion before the agent offers its own.
- Three concrete tactics help: build a quick throwaway prototype first ,rank priorities before touching solutions , andforce the agent to argue against itself .
- None of this is fully solved. Treat it as an ongoing discipline, not a one-time fix to your planning skill or prompt template.
made for the enterprise.
What did Anthropic’s study actually find? #
Anthropic ran an experiment where expert analysts worked with an AI agent on analytical decisions. Unknown to the analysts, each agent was configured through its system prompt to favor one option on each decision, with the direction randomized. The agent was also instructed to argue its case, while still being willing to change its position if given strong enough evidence.
The results were consistent across the board. Analysts followed the agent’s lean 86% of the time. When analysts had already formed and stated their own opinion before the agent weighed in, they abandoned that opinion 60% of the time if the agent pushed back, compared to only 6% when the agent agreed with them. Afterward, when asked to explain their reasoning, 77% of analysts used arguments that came directly from the agent, sometimes nearly verbatim, but only 15% acknowledged the agent as the source. In a self-assessment, 52% of analysts described the final call as more their own than the agent’s, despite the agent’s lean having shifted their decision most of the time.
Anthropic also found that experience didn’t predict who deferred and who didn’t. People who were confident and skilled in their domain were just as susceptible as anyone else. The study covered one task in one field with one model, and Anthropic flags that limitation itself. But the pattern it describes, confident agent output quietly becoming “your” conclusion, lines up with what a lot of people doing agentic coding work see constantly in their own planning sessions.
Why does this happen during coding agent planning? #
Most agentic coding workflows now start with some kind of planning or clarification step before implementation. You describe what you want to build at a high level, and the agent asks a series of clarifying questions, often through a structured question tool that presents multiple-choice options. The agent almost always attaches a recommended answer to each question.
This setup is efficient. It’s also exactly the structure that produces deference. Answering “agreed” to a list of agent-generated questions feels like active decision-making because you’re technically making a choice each time. But picking the agent’s top recommendation over and over isn’t the same as reasoning through the tradeoffs yourself. The failure mode is passivity: a plan gets produced, you nodded along to each step, and the document is really the agent’s thinking from start to finish, with your name on top.
This isn’t unique to any one skill or tool. It shows up in any workflow where an agent proposes a direction before you’ve committed to one of your own, which describes most agentic coding planning as it’s typically practiced.
What are practical ways to keep your own judgment in the loop? #
Remy.
claims.northwind.internal Your servers. Your domain.
1,902
214
17
3.2h
CLM-20417 · M. Alvarez$4,120
Approved
CLM-20418 · D. Okafor$880
In review
CLM-20419 · S. Lindqvist$12,300
In review
Prototype before you plan. Instead of jumping straight into a structured planning session where the agent presents options with recommendations attached, build a small, rough, throwaway version of the thing first. Spending even twenty or thirty minutes getting hands-on with a scrappy implementation gives you real opinions grounded in direct experience, rather than opinions borrowed from an agent’s confident-sounding explanation of tradeoffs you haven’t actually felt yet.
Rank priorities before touching solutions. A lot of planning sessions go wrong because they jump straight to implementation details: which library, which pattern, which file structure. Before any of that, have the agent surface the actual priorities and tradeoffs at stake (speed versus flexibility, simplicity versus extensibility) and force yourself to rank those priorities before the agent proposes specific solutions. If you lock in what matters most to you first, you’re far less likely to be swayed by a confidently argued recommendation that quietly optimizes for a priority you didn’t actually choose.
Make the agent argue against itself. Once you have a leaning answer, ask the agent to build the strongest possible case for the opposite position. Large language models are good at sounding certain even when they’re wrong, and that confidence is persuasive by default. Deliberately generating a devil’s advocate argument breaks the one-sided momentum of “agent recommends, human approves” and gives you something to actually weigh instead of rubber-stamp.
None of these tactics make the problem disappear. They just insert friction at the points where deference is most likely to happen quietly.
Is this actually a reason to use AI less? #
No, and Anthropic’s own writeup is explicit about this: the problem isn’t AI itself, it’s unreflective deference to it. The study also notes that analysts working entirely without AI made more serious errors and took longer, which matches the general experience of most people using agents for real engineering work. The goal isn’t to strip the agent out of your workflow. It’s to change the order of operations so you form a position before the agent offers one, and so the agent’s output gets treated as an input to your reasoning rather than a substitute for it.
There’s a broader version of this problem too. When one team uses an agent to write a pull request and another uses an agent to review it, both are ultimately shaped by the same underlying model’s preferences, even if the two steps feel independent. Anthropic points out that when multiple results all trace back to agents with similar tendencies, apparent agreement between “independent” reviewers may not be as independent as it looks. That’s a harder institutional problem to solve, but the individual version (am I actually thinking, or just agreeing) is something you can address in your own workflow starting today.
Frequently Asked Questions #
What is AI disempowerment in the context of coding agents?
It refers to the gradual loss of independent judgment that happens when people consistently defer to an AI agent’s recommendations during planning or decision-making, often without realizing they’re doing it, and then later believe the conclusions were their own.
Does more coding experience protect you from this effect?
According to Anthropic’s study, no. Analysts’ level of experience and expertise did not predict how often they deferred to their agent’s recommendations. Confident, skilled people followed the agent’s lean about as often as anyone else.
demandsof enterprises.
Does this mean I should stop using planning skills or clarification tools in my agentic workflow?
No. The tools themselves aren’t the problem. The issue is the order of operations: if the agent always proposes a recommended answer before you’ve formed your own view, you’re more likely to default to agreement. Forming an opinion first, through a prototype or explicit prioritization step, changes the dynamic.
How can I tell if I’m actually using judgment or just agreeing with my agent?
A useful test is whether you can explain your reasoning without repeating the agent’s own phrasing or argument structure. If your justification for a decision sounds like a direct echo of what the agent said, there’s a good chance the agent made the call and you approved it after the fact.
Is this problem considered solved?
No. Anthropic frames it as an open area for further research, including how to measure deferral, how to design agents that invite more scrutiny, and how institutions should treat “expert sign-off” when much of the underlying work was AI-generated. Individual strategies like prototyping first or arguing the opposite case help, but they manage the problem rather than eliminate it.