FROM: https://x.com/addyosmani/status/2117512471930167377?s=12&t=4kCb1gN1qYTWVHTJnmDaKA

Delegate the Work, Not the Judgment

Back in the day, critical thinking was taught as approaching new information with humble curiosity and a healthy dose of skepticism: take in different views, form your own opinion. That's still true, but increasingly, nothing in my day-to-day forces critical thinking on me now that so much of my work runs through agents. For the engineers and product people who have fully bought into agentic workflows—running multiple sessions in parallel and expecting the models to improve—I'll say this up front: I'm a big fan of these tools. I'm not writing this to advocate for fewer agents.

My goal is different. When it's this easy to hand anything to an agent, how do you keep critical thinking in your day? Because by default, nothing will do it for you.

The space for thought has shrunk to seconds

In the past, most of our cognitive and aesthetic processing happened in the space between question and answer. That space is now measured in seconds. The more you use agentic workflows, the harder it gets to keep your judgment—though not in the way people expect. As models improve, the percentage of obvious errors drops. Many (most?) outputs will be well written and mostly correct, so they no longer demand a second look.

Even if you're running many agents at once, you still only have one pair of eyes on the outputs. So you have to build critical thinking into your day, the way you build in any other routine. What makes it hard is that agentic workflows are pleasant: getting fast, pleasant, often-correct answers is refreshing in a busy day, and that's exactly why it's easy to relax your vigilance.

From offloading to surrender is a three-step slide

When I discuss this with people, I describe it as a spectrum.

At the top is cognitive offloading: delegating tasks to AI while keeping ownership of the result. I do this all day. You should, too. In the middle is deferral: the tool's output becomes your new input, and the result stops being a hypothesis. At the bottom is cognitive surrender: the AI's output quietly becomes your own, and you feel no need to check it.

The term was coined by Steven Shaw and Gideon Nave at Wharton, and it fits neatly with what I've been seeing: as trust (or laziness) increases, people drift down the spectrum. The transition is rarely observed, because each step is gradual and seems reasonable. You read the last answer carefully, so you skim the next one. You scan only the skeleton of the one after that. Then someone asks you about a line and you can't explain it, even with your agent's help.

That's how cognitive debt accumulates. It usually surfaces when you try to apply a mental model of the system and find that it doesn't exist. Margaret-Anne Storey has written about how this shows up in teams as an eroding understanding of a shared system theory; Jeremy Twei coined the term comprehension debt, and I've written about the code equivalent. In the moment it's completely invisible. The codebase looks pristine and the tests pass. It doesn't become obvious until you have to change the system and realize that nobody understands it anymore. Reading the table of contents of a strategy doc or spec and signing off on it is the same thing.

To be clear, I'm not advocating for the impossible. Maintaining a full mental model of a large modern codebase is impossible. The Claude Code team has said publicly that they rebuild understanding on demand: when they need to understand a part, they ask Claude to explain that slice rather than holding the full model in their heads. As I've written before, this kind of debt is more recoverable than most engineers expect. You don't need to maintain the full model as long as you can rebuild it locally when needed. You just need to know what you don't have.

Where the stakes are low, feel free to delegate entirely. But when you can't explain the answer even with your agent's help, you've ceded ownership. That isn't always a problem. Just recently, I was recording a course and had to pick one of three similarly rated hotels as a recording location. I didn't have time to read all the reviews, so I delegated the decision to an AI. It worked, and I'd do the same again. But I wouldn't do that when deciding how to invest our money, how to advise our kids on their careers, or at work: what we should build, which users a change affects, whether it's safe to ship. Take the handoff where being wrong is cheap; keep the reasoning where others will have to deal with the consequences.

Six questions I ask myself before I ask

When I didn't know what I thought, I'd usually go back to a basic list of questions: How do I know I'm working on the right problem? How do I know I'm solving it the right way? Is there evidence that supports my conclusion? How do I know I'm finished? Most of the time it's just who, what, where, why, when, and how. Written out, it looks absurdly childlike, but it forces you to think in categories you'd otherwise ignore. These days it's too easy to skip all of that and just ask your agent what it thinks you should do. These are the versions I ask myself now.

Did I form a hypothesis before asking? Before I run an agent on any non-trivial task, I write down—even just in my head—what I think the answer might be. It's fine if it's a bad guess; you're always welcome to change your mind in light of new information. But once you've read a well-written response, it's hard to imagine any other possibility. If you have no idea at all, ask for what Thariq Shihipar calls a blind-spot pass: give the model what you know and have it find your unknown unknowns.

Am I asking it to help me think, or to offload thinking from me? Both are fine, as long as you know which one you're doing.

What would have to be true for this to be wrong? Then go find out. A model's self-assessment of confidence is much less valuable than an actual test you can run, so give it one.

Have I heard the counterargument from a different angle? When I've taken a hard stance on something somewhat open-ended, I'll ask more than one model to argue the opposite side, then review the output and form my own opinion. It takes longer, but I end up knowing much more about the subject.

Would I bet on this in front of the person who has to maintain it? This applies to code and to anything else you deliver. I think that's the bar for answerability.

What am I no longer practicing? Maybe some routine debugging. I'm okay with letting some of that go, but I want it to be intentional.

Make verification a habit, not a green check

I've been writing a lot about verification lately because I believe the bottleneck has shifted from writing code to being sure you're right. When you give an agent the means to verify its work—end-to-end tests, property tests, actual app interactions—it can make a change, run the verification, read the output, and try again all before you've looked at anything. This is what Boris Cherny calls "give Claude a way to verify its work," and I believe it's one of the most critical components of getting great results. Rather than reading every line, you build these loops and review the evidence.

But you can also surrender verification. "Is there evidence that supports my conclusion?" becomes "Did the check turn green?" Agents make tests so cheap to create that you'll see a lot of green, and a passing test can fail to catch a broken feature: if the test is written with the same mistake as the feature, it will pass. And a green check conveys only one property, yet it's far too easy to imagine it covers everything. When a check goes green, ask what it proved. Then ask what it didn't. Define "verified" up front, because afterward you'll rationalize any outcome.

The finish line for agent work should be something tangible: a passing test, a screenshot, a log or trace. That makes the definition of done factual, rather than "it looks done"—which is open to interpretation and surrender. When you get a completion notification from an agent, review the command it ran and its output before you read the summary.

Claude Code can also self-critique in a subagent with a fresh context as a sanity check, and it's worth baking that into the loop so it runs every time, not just when you remember. At the end I still ask, "Did I miss anything?" It sounds silly, but so often, when I finish complex feature work with a frontier model, look at it, review it, and then ask, "Did I miss anything?", it comes back with two or three more things. That's why I always ask.

None of this needs to be the norm, of course; knowing when to go deep is a skill. My favorite rule of thumb from the Claude Code team's write-up on code review is this: "If you can't say what the checks would miss, ask for a real review rather than a quick approval."

This applies beyond code, too. If an agent has synthesized fifty customer calls or a competitive analysis for you, check a couple of the source documents to make sure the summary is accurate. Check a number your recommendation depends on to make sure it's calculated correctly. Agents have made verification cheap to set up; what's hard is knowing what good verification looks like.

Actually pay attention to what was generated

Say an agent hands you a 600-line PR. You roughly scan the structure. You don't read every line. The variable names look reasonable and the tests pass, so you approve it. But somewhere in the middle there's a subtle ordering change at a transaction boundary, or a flipped default on an edge case you never thought about. You did review it—but only for what you already knew you'd find.

Writing code and reviewing it are different skills, and at some point reviewing turns into rubber-stamping. So read the diff as if the AI didn't write it, and then look past the diff at what the agent decided. Over a long session it makes a lot of small decisions for you: the defaults, what's out of scope, which requirement it reinterprets when two of them clash. You won't see any of that in a summary that says everything went well. So ask it to list the decisions and assumptions it made, then quiz yourself: pick a few lines at random and ask what this line is doing. What about that one? For a document, close it and try to write out the main argument from memory. Some people have a habit I like for long sessions: have Claude write a report on the change, then add a quiz at the bottom, with the rule "I only merge after I pass it perfectly."

Understand what you're shipping well enough to defend it. Because at some point, someone could ask.

Agents can also guard your attention. For example, I have an open-source project that receives a lot of pull requests. I'll use agents to figure out what's coming in, what runs contrary to our guidelines, and where my attention is likely required. I rarely let the agents decide that themselves, but they can narrow down where I should focus—and then I can actually think about whether these changes are solving the right problem the right way.

Then there's volume, and you have to be honest with yourself about it. I've called this the orchestration tax: the gap between what your agents generate and what you'd feel comfortable putting your name on. If finished work is piling up faster than you can get through it, another session won't help until you close that gap—either tighten the checks so less of it needs you, or slow down. When you're producing more than you can stand behind, you're no longer reviewing. You're hoping.

Quality in, quality out

The human mental model is still involved, but instead of sitting in the middle, it's at the front and the end. You put your energy into the front end of the task description and context, and into the back end of reviewing the output. That's why good input matters so much to output quality, and why I view good prompting as a critical-thinking skill.

Historically, if you made a vague request, someone would challenge it, and you might realize, "Oh wait, I actually hadn't figured this out." An agent often won't stop you there. It fills in what you left out and hands back something that looks done, even though the idea behind it is still fuzzy. I've written about this as intent debt: the implicit goals, constraints, and rationale that live in artifacts you didn't write. Unlike other kinds of debt, nobody else can pay this one off for you. The intent has to come from you.

Your prompt is a reflection of your understanding of the problem. If you can't express it clearly, it may not be clear in your own mind.

Write your own request brief in your own words before you ask for help. Describe the audience, the out-of-scope items, and the definition of done. When your second round of corrections hasn't gotten you there, stop tweaking and rewrite your prompt.

You can have the agent help you with this, too. I like Andy Clark's distinction between delegating to an AI system and collaborating with it. In the latter case, you're in a virtuous cycle of mutual amplification: your prompts sharpen your output, which sharpens your next prompt and your mental model of the problem. If it's not clear, ask the agent to interview you about what it doesn't understand. If you close the session having refined your own mental model, that's a sign of success.

Be careful about the input, too. It's easy for each agent to pass the previous agent's summary into its context, and before long the third agent hasn't read the original document.

You also need your own standards for output. I've played with AI in a lot of different creative mediums, and most of it never gets shown because it doesn't meet my standards. Everything comes out nicely formatted and confident now, so polish is no longer a useful signal. AI may have made production faster, but if I wouldn't feel comfortable attributing the output to myself, I won't put it out.

When something doesn't meet your standards, note why in shared config, a hook, or a test so it doesn't happen again. That's how taste compounds—and noting why something didn't make the cut is good practice on its own.

"But the models will be better at this than me"

If you're as bullish on the future of this space as many people around me, you've probably had this thought during a couple of the sections above. In a year or two, the model will be able to detect what I'd be able to detect, so why bother maintaining the skill?

You may be right about a lot of that detection, and I've been arguing for pushing more and more of it to agents myself. But here's why I think it still matters: at the end of the day, someone is responsible for what ships. Regardless of how much AI helped, a human has to take responsibility.

And the question of how much to trust an agent on any given task is itself a judgment call. Part of staying calibrated is reviewing the work, because what the models get wrong keeps changing. Anthropic's own research on its engineers and researchers names the trap the paradox of supervision: "supervising Claude requires the very coding skills that may atrophy from AI overuse."

Some of the things that matter most to me are things a better model won't solve: what are you building, why is it worth it, who does it impact, and what are you willing to sacrifice? Those are all questions you need to answer. An agent can help you work through them—I'd like it to—but ultimately they're still yours.

You may offload the work and much of the auditing, but not the accountability.

A few practices for the everyday

You don't need to do all of this rigorously. Just plug in what works for your workflow.

Once a week, write a bit of code without an agent, or do one real thing that would suck if you forgot how to do it. I've called this a calibration exercise, but I don't mean it as a moral one. Once a month, write down what you've stopped doing and decide which of those you're okay not doing. One question from an old blog post of mine remains as valid as ever: How lost would you be if AI didn't exist?

If something is above your comprehension, go learn it. If I'm writing and run into a phrase I haven't seen before, I could Google a one-line explanation and include it. I prefer to do a little research and properly understand it, so I can see where it fits.

Checking the machine properly is real work, and pretending otherwise is how teams end up not doing it. It isn't free, so schedule it as a line item and you'll actually get it done.

Skills you stop exercising will go away, probably faster than you might guess. Keep doing the ones you're not willing to let go.

What to take with you

Be intentional. An agent can quiz you, interview you, and show you its evidence—but only if you set that up. So set it up.

Be honest about your place on the spectrum. If you can't explain the answer, even with an agent's help, you've surrendered it.

Have a hypothesis. Formulate one before asking, even if it's bad.

A green check means one thing. What did it check? What did it not check?

Look for evidence. Read what it ran and what it returned before you read the summary.

Read to know what decisions it made. What did it decide for you?

Craft your prompt. How you write it shows how much you understood the problem.

Set a bar, and stick to it. If you wouldn't put your name on it, it doesn't go out.

Keep yourself in the game by applying the skills that matter by hand. One thing you could do: before you ask, write down what you think will happen; after the agent is done, write down one thing it didn't check. See if that changes the way you read the output. Think independently. Ask better questions. Take responsibility for the outcome.