How to Maintain Critical Thinking as AI Agents Take Over Work

Author: Addy Osmani (Anthropic Claude Code Team, renowned technical architect)

Compiled by Deep潮 TechFlow

Shenchao Overview: As agentic workflows are fully deployed, software engineers and product teams are undergoing a profound transformation in human-machine collaboration paradigms. The cognitive buffer zone that once fostered reflection between question and answer has now been compressed to just a few seconds; as large models become increasingly realistic and highly accurate, explicit errors have sharply declined, yet people are gradually slipping into “cognitive surrender” amid a pleasurable sense of compliance, while their systemic understanding and foundational skills are quietly eroding.

As former head of engineering for Google Chrome and current core member of the Anthropic Claude Code team, Addy Osmani systematically analyzes the spectrum shift from "cognitive offloading" and "delayed judgment" to "cognitive surrender." He not only dissects the hidden mechanisms of accumulating systemic understanding debt but also proposes a practical and defensive set of active reading and adversarial questioning strategies for daily workflows, arguing that even in a future where AI holds higher success rates, humans must still firmly uphold their responsibility boundaries and critical thinking abilities.

At one time, schools taught critical thinking as requiring a humble curiosity and a measured skepticism when encountering new information: gathering diverse perspectives, listening widely to gain clarity, and ultimately forming one’s own independent judgment. This principle remains valid today, but now, as most of my daily work is handled by agents, there is virtually nothing in reality that forces me to engage in critical thinking.

For engineers and product professionals who have fully embraced agent workflows, run multiple sessions concurrently in their daily routines, and patiently await continuous improvements in model performance, I want to first clarify: I am myself a devoted advocate of these tools. I wrote this article not to encourage anyone to reduce their use of agent workflows.

My core goal is to help you maintain your critical thinking in a world where everything can easily be outsourced to agents.

In the past, most of human cognitive processing and aesthetic judgment unfolded in the spaces between questions and answers. Today, however, the scale of that space has shrunk to just a few seconds. The deeper you engage with agent workflows, the harder it becomes to stay alert—though this difficulty may not manifest as commonly expected: as models continue to improve, blatantly absurd errors have drastically decreased. Most generated outputs are written with remarkable polish and are largely correct, yet it is precisely this seemingly flawless professionalism that makes people reluctant to look a second time.

Even if you're running dozens of agents in parallel, the final evaluation of the results still rests with your own eyes.

You must proactively embed critical thinking into your daily processes, because in the default state, no external force will safeguard you.

One reason people struggle to self-correct is that the experience of agent workflows is simply too delightful. On a hectic workday, quickly receiving a decent, comfortable, and mostly correct answer is incredibly refreshing—but it’s also precisely what makes people prone to letting their guard down completely and surrendering entirely.

When discussing this phenomenon with peers, I typically describe it as a continuous spectrum:

At the top of the spectrum is "cognitive offloading"—delegating specific, tedious tasks to AI, while humans retain absolute ownership and responsibility for the final outcome. I do this every day, and you should too.

In the middle of the spectrum is "Deferral," where the tool’s output becomes your next input directly, and the generated content is no longer treated as a hypothesis requiring validation.

At the far end of the spectrum lies "cognitive surrender": the AI’s output subtly becomes your own belief, and you instinctively feel there’s no need to verify it at all.

The term "cognitive surrender" was coined by Steven Shaw and Gideon Nave of the Wharton School. It precisely captures what I have recently observed: as trust in tools increases (or inertia takes hold), people unconsciously slide along this spectrum.

This slippage is often extremely subtle and hard to notice, because each step happens gradually and seems perfectly reasonable at the time: you carefully read the previous response, so next time you only skim it; then you merely glance at the outline; until one day, when someone points to a line of code and asks you about it, you suddenly realize that even with the help of an AI agent, you cannot explain its underlying logic at all.

This is a classic case of cognitive surrender—the very source where cognitive debt quietly accumulates. This debt typically becomes apparent when you attempt to invoke your system’s global mental model, only to find your mind empty.

Scholar Margaret-Anne Storey has written that this manifests in team collaboration as a gradual erosion of shared understanding of system theory. I have also written about the corresponding phenomenon at the code level, termed “comprehension debt” (a term coined by Jeremy Twei). In day-to-day coding, this debt is entirely invisible: the codebase appears clean and elegant, and all automated tests pass with green status. Yet, whenever the system requires architectural refactoring, everyone is left staring at each other in awkward silence—no one on the team truly understands how the system works. The same issue occurs when you glance briefly at the table of contents of a strategy document or technical specification and then sign off without thorough review.

It’s important to clarify that I’m not advocating for an unrealistic perfectionism. It’s impossible for engineers to maintain a complete mental model of an entire modern codebase at all times. The Claude Code team has previously stated publicly that they now adopt a “reconstruct understanding on demand” strategy: when modifying a module, they directly have Claude explain the logic of that specific section, rather than trying to hold the entire system in mind.

As I previously noted, this kind of localized understanding debt is actually easier to remedy than most engineers realize. As long as you can reconstruct the necessary understanding on demand, you don’t need to maintain the entire big picture at all times. But the bottom line is: you must be fully aware of where your blind spots lie.

For trivial matters with extremely low cost of trial and error, you can confidently hand over full decision-making authority. But once you face a critical issue—even one where an agent cannot explain its underlying answer—you have effectively relinquished all ownership of the system.

Of course, this doesn't mean every situation requires such caution. Recently, I needed to record a course and had to choose one of three hotels with similar ratings as the venue. I simply didn't have time to sift through countless guest reviews, so I entrusted the decision entirely to an AI. The result was highly satisfactory—I would do the same again in a similar situation.

However, when it comes to core asset investments, planning your children’s careers, or deciding in your job which features to develop, which real users will be affected by changes, or whether the code meets security standards for release, I would never relinquish decision-making authority. In low-stakes peripheral areas, you can freely delegate; but in critical areas where others must bear the consequences, you must firmly hold on to human reasoning.

When I’ve previously found myself lost in confusion, I would retreat to a simple list of fundamental questions: How do I know I’m solving the right problem? How do I know I’m using the right approach? Is there solid, objective evidence supporting my conclusions? How can I confirm that this work is truly complete? Most often, these are simply the classic journalistic “Five Ws and an H” (Who, What, Where, Why, When, and How). Written down, they may seem childish or trivial—but they force you to examine issues from perspectives you’d otherwise easily overlook.

In this era, people are too quick to skip all these difficult reflections and instead turn to agents asking, “What do you think I should do?” Therefore, I’ve updated my personal reflection checklist for the age of agents:

Before asking, have I already formed my own initial hypothesis? Before launching an agent to handle any non-trivial task, I force myself to write down—either in my mind or on a sticky note—what I think the possible answer might be. Even if it’s just a rough, flawed guess, that’s perfectly fine. You’re always free to discard and change your mind after encountering new information. But once you’ve read a beautifully written generated response, it becomes very hard to imagine any other possibility. If you’re completely stuck, try the “blind spot probing” method described by Thariq Shihipar: lay out all the facts you know and ask the model specifically to help you uncover what you don’t even realize you don’t know.

• Am I using it to assist my thinking, or am I outsourcing my thinking entirely to it? Both modes are acceptable, but the key is that you must remain fully aware and clearly understand which state you are in at any given moment.

• What conditions must be in place for this strategy to completely fail? Once you’ve thought it through, immediately go and test it in practice. The model’s self-assessment of its own confidence is far less valuable than running an actual test—so give it a real litmus test.

• Have I considered counterarguments from opposing perspectives? When I form a firm stance on an open-ended question, I ask the model to act as a critical devil’s advocate, specifically listing the strongest rebuttals against my position. This isn’t necessarily meant to overturn my decision, but to force myself to confront blind spots that would otherwise be instinctively filtered out when things are going smoothly.

• If I had to defend this result myself, what would I say? For now, close the agent window and try explaining this plan to a colleague in your own simple, everyday words. If you find yourself stumbling and struggling to make it clear, that means you don’t truly understand it yet—you’re just mechanically acting as an AI echo.

In passive reading mode, your mind simply glides mechanically along the predetermined text, passively receiving the stream of information. Because the text generated by AI agents is typically fluent, elegantly phrased, and grammatically flawless, passive reading in this context makes it extremely easy to mistakenly believe you’ve fully grasped the essence. It’s like watching a top-tier speaker demonstrate seamless architecture operations at a tech conference, nodding along in the audience as if it all makes perfect sense—only to return to your hotel room, open a blank editor, and realize you can’t write even the first line of code.

Active reading is a critical examination driven by adversarial assumptions. It not only pays attention to what the text says, but relentlessly questions: Why is this written here? What core challenges has it avoided? Why was this particular solution chosen over another?

For lengthy proposals generated by agents, I typically read them with two very clear critical perspectives:

First, identify the “missing context”: What implicit assumptions does it make? Does it overlook any edge cases? When two requirements conflict, what principles does it silently use to make trade-offs for me?

Second, proactively pose challenging questions: What would happen to this design if concurrent traffic suddenly spikes tenfold? What cascading failures would occur if a third-party external dependency service went down for thirty minutes? Instead of passively reading through prewritten answers, take the scalpel into your own hands and perform stress tests.

Agents can do more than write lengthy essays—they can also be trained to become powerful allies in helping you engage in deep critical reading. The key is not to simply ask them for pleasing conclusions, but to have them reveal the underlying disagreements and fractures:

You can have it cross-examine two seemingly opposing architectural designs, highlighting what each side has compromised; you can have it play the role of a harsh code reviewer, specifically identifying poorly written code that passes tests but hides future maintenance pitfalls; you can even have it, after generating a long text output, randomly select three details from within and ask you reverse questions to test whether you truly understood the context.

Treat agents as a whetstone for your thinking, not a replacement for it.

Writing code and reviewing code are entirely different cognitive skills. Faced with massive streams of generated code, human review easily deteriorates into mindless rubber-stamping due to fatigue.

Therefore, when reviewing code changes (Diff), please pretend this code was not written by an all-powerful AI, but rather submitted by a new intern. More importantly, don’t just focus on the added or removed lines—look beyond the surface code and question the significant micro-decisions the agent quietly made on your behalf: What default values did it choose? Which complex logic did it silently exclude from this scope? When two product requirements conflicted, which one did it quietly reinterpret?

If a report merely brushes over things by saying, “Everything is fine, all tests passed,” you’ll never see the inner workings behind any critical decisions. Therefore, explicitly request a separate checklist that details the subjective assumptions and trade-offs made during this task. Then, randomly audit yourself: pick two or three lines of key code and ask yourself why you wrote them that way. If this were a design document, close the page and try to recite its core arguments from memory to someone else. I particularly admire a rigorous practice adopted by some teams: requiring agents to include a self-assessment quiz at the end of their change report, with the team’s strict rule being, “Code is not allowed to be merged until I answer 100% of the quiz questions correctly.”

Make sure you have a deep understanding and confidence in the products you deliver and launch, so you can always stand up and defend them—because one day in the future, someone will definitely come to you with questions.

Meanwhile, agents can also help us build valuable defenses for our attention. For example, I maintain a large open-source project that receives a massive volume of pull requests. I use agents to perform initial screening: identifying which submissions violate community contribution guidelines and which require my focused attention. I would never let agents make the final decision on whether to merge, but they help me precisely narrow the attention funnel, allowing me to direct my limited human cognitive bandwidth toward the critical question: “Are these changes solving real problems in the right way?”

Finally, we must confront the psychological inflation caused by output explosion. I call this the “Orchestration Tax”—the vast gap between the massive volume of industrial-grade content generated by agents and the much smaller volume of high-quality work you’re truly proud to put your name on. If the pace of output accumulation has far exceeded your physiological capacity for careful review, launching additional concurrent sessions won’t help: you must either tighten your automated validation processes or decisively slow down.

When what you produce goes beyond the scope of what you can reasonably vouch for, you are no longer conducting professional review—you're merely hoping for the best.

In human-machine collaboration systems, the human mental model has not disappeared—it has simply shifted its focus: it has been moved entirely from the lengthy intermediate encoding phase to the front-end task input and the back-end output validation. You channel all your cognitive effort into decomposing tasks and providing context at the outset, and into rigorous auditing and closing the feedback loop at the end. This is precisely why the quality of prompts has a decisive impact on the final outcome—I have always regarded excellent prompt engineering as a core skill of advanced critical thinking.

In the past, if you presented a vague, ambiguous requirement to a human colleague, they would immediately push back, prompting you to realize in response: “Actually, I never fully thought this through.” However, agents often won’t stop you at this point. Instead, they silently fill in all the missing details you overlooked and deliver a surface-level polished and complete output—efficiently, even—while the core intent behind it remains muddled. I call this phenomenon “Intent Debt”: implicit goals and constraints quietly embedded in deliverables that you yourself have never truly examined. Unlike other forms of debt, no one else can repay your Intent Debt—the core intent must come 100% from you.

The prompts you write are a mirror reflecting the depth of your understanding of the problem; if you cannot express it in clear, precise language, it often means it’s already a jumble in your mind.

Before seeking external computing power assistance, first write a task requirements outline in your own simple, straightforward language. Clearly define the target audience, set absolute boundaries that must not be crossed, and provide objective criteria for completion (Definition of Done). If, after a second round of revisions, the results still fall short of expectations, immediately stop making blind adjustments and completely rewrite your input prompt.

You can also use agents to push yourself to improve the quality of your inputs. Philosopher Andy Clark made a profound distinction between “unidirectionally delegating tasks to AI” and “engaging in deep bidirectional collaboration with AI.” In true collaboration, you enter a virtuous feedback loop: your precise prompts generate exceptional outputs, and those outputs, in turn, push you to refine even deeper prompts—ultimately significantly deepening your mental model of the system. If you’re unsure whether your logic is sound, have the agent interview you in reverse, probing areas it doesn’t yet understand. When, at the end of a conversation, your own internal logic feels more complete and elevated, that’s the true mark of success.

Additionally, context pollution must be strictly monitored. When multiple agents collaborate, it is easy for subsequent agents to rely solely on the compressed summaries of their predecessors, leading to progressive degradation—by the third agent, the original core document may never have been read at all.

At the same time, you must establish your own standards of aesthetics and quality. I have extensively experimented with AI across numerous creative and engineering fields, and the vast majority of outputs were never published because they failed to meet my personal standards. In today’s era, all model outputs can be polished with flawless formatting and delivered with unwavering confidence, making “surface smoothness” no longer a reliable indicator of quality.

AI may have greatly accelerated the content production pipeline, but I will never allow anything to be published if it makes me uncomfortable putting my name on it.

When a deliverable fails to meet standards, explicitly document the specific reasons in shared configuration files, Git hook interceptors, or automated test cases to ensure the same mistake never happens again. This is the true path to compounding taste and standards—and simply recording what failed to meet the threshold is itself a highly valuable form of cognitive practice.

If, like many passionate practitioners around me, you hold a strong bullish belief in the future of AI, you may have already thought while reading the earlier chapters: “In another year or two, models’ ability to correct errors and provide insights will surely far surpass mine—so why bother maintaining these critical review skills?”

On many purely technical indicator analyses, your predictions are likely entirely correct—I myself have long advocated for delegating more and more automated detection authority to agents. But why is this capability still of paramount importance in the future? There is only one reason: ultimately, a real, flesh-and-blood human must bear full responsibility for the tangible outcomes delivered. No matter how much computational power is invoked behind the scenes, it is always a real human who stands trial or bears the consequences.

Deciding the appropriate level of trust to assign an agent for a specific task is itself a qualitative judgment requiring exceptional wisdom. To maintain precise calibration in your assessments, you must continuously review the work firsthand, as the peculiar patterns in which models make errors are constantly evolving. Anthropic’s longitudinal studies of its top engineers and researchers have profoundly highlighted this deadly trap of the “Paradox of Supervision”: the advanced engineering and architectural expertise required to supervise and guide Claude are precisely the core skills that humans are most likely to rapidly atrophy through overreliance on AI.

These ultimate questions are the ones I value most—questions no matter how powerful a large model may be, it can never answer for you: Why are you building this product? What social and commercial value does it truly hold? Which specific people will it profoundly impact? What costs and compromises are you willing to make to bring it to life? All of these must be answered by you alone. While AI agents can shine in helping you work through these questions, and I welcome that, the final decision—and the seal of approval—will always rest in your own hands.

You can offload specific tasks and even large audit processes entirely to algorithms, but ultimate accountability and responsibility can never be offloaded.

You don’t need to rigidly follow all doctrines—simply adopt the approaches that fit your workflow and integrate them naturally:

• Weekly offline deliberate practice: Set aside a fixed time each week to completely disconnect from agent assistance and manually write a piece of critical code, or personally complete a core business task that could have serious consequences if neglected (I refer to this as cognitive calibration practice—this is not moral coercion).

• Monthly Capability Audit: Each month, regularly create a list documenting tasks you’ve stopped doing yourself due to reliance on AI, and seriously reflect: Which of these abilities are you truly comfortable letting go of permanently? The question I posed in an old blog post years ago remains as compelling today as ever: If AI were to vanish completely tomorrow, how paralyzed and lost would you be?

• Always delve deeply into anything unclear: If you encounter a concept beyond your current understanding, take the time to study it systematically. When writing an article and coming across an unfamiliar term, I could simply copy a Wikipedia definition and insert it into the text—but I prefer to set aside a short period for in-depth micro-research, understanding its origins and implications until I clearly see its place within the broader knowledge landscape.

• Schedule machine review as a formal task: Conducting rigorous, genuine reviews of machine outputs is an extremely demanding and intensive cognitive workload. Pretending this work is easy is precisely what causes many teams to ultimately abandon review entirely, leading to catastrophic consequences. Review is not a free lunch—officially include it in your daily schedule so you can genuinely allocate the energy needed to carry it out properly.

• Skills you stop practicing will rapidly deteriorate: Any cognitive muscle you neglect for an extended period will atrophy faster than you intuitively expect. Be sure to consistently practice hands-on the core skills you refuse to give up.

• Maintain clear intent: The agent can fully reverse-test you, interview you, and present underlying arguments—but only if you actively design and configure this collaboration mechanism. So, set it up immediately.

• Honestly acknowledge your true position on the spectrum: if you cannot even explain the reasoning behind an answer to others without prompting from an agent, then admit that you have succumbed to cognitive surrender.

• Always ask with preset assumptions: Before posing a question to AI, form your own hypothesis—regardless of whether it’s right or wrong.

• A green checkmark only indicates that one test has passed: always ask—what exactly did it check? What did it quietly overlook?

• Examine the objective evidence first, then read the subjective conclusions: Before reviewing its polished summary, carefully review each line to see exactly which real commands were executed and which underlying data were accessed.

• Read with sensitivity to decision-making: Understand exactly which micro-decisions the agent has made on your behalf in this output.

• Refine your input prompts carefully: The depth and structure of your prompts directly reflect your true mastery of the problem's essence.

• Establish and strictly adhere to an absolute quality threshold: If you’re not proud enough to put your name on it, do not approve it.

Stay firmly at the center of the board by consistently practicing the essential core skills yourself. One minimalist daily habit you can try immediately: before asking an AI agent a question, write down your predicted possible outcomes on a sticky note; after the agent delivers its response, immediately note down one blind spot it failed to address. See if this small adversarial habit can fundamentally transform the depth of your thinking when evaluating AI outputs. Think independently, ask higher-quality, more insightful questions, and take full responsibility for the final outcome.

Diagram: Maintaining Independent Thinking and a Responsibility Loop in AI Agent Workflows