Claude Cowork is an async agent running tasks in the background while you do other things. That model is powerful, but it is not always the right one. Using Cowork on the wrong kind of task wastes the setup time and often produces worse output than a focused chat session would have.
This guide is about judgment. Specifically, when to hand something off and walk away, and when to stay in the conversation instead. If you are new to the tool, what is Claude Cowork covers the basics first.
What is the difference between Cowork and a chat session?
Cowork is designed around a hand-off model. You assign a task, Cowork executes it, you return to a finished artifact. The loop is: brief, run, review.
A regular Claude chat session is designed around iteration. You probe, Claude responds, you refine, Claude adjusts. The loop is continuous and cheap.
These two loops suit fundamentally different types of work.
What tasks is Claude Cowork good for?
A task is a good fit for Cowork if all three of the following are true.
It is well-scoped. The goal, inputs, and expected output are all defined before you start. "Summarise these five meeting notes into one page, bullet points only, saved to notes/weekly.md" is well-scoped. "Help me figure out what our Q3 strategy should be" is not.
It is independent. The task does not require decisions from you mid-run. If completing it correctly requires your judgment at step 3, Cowork either stalls or guesses. Neither is what you want.Common gotchaThe hidden decision is the one that bites: a task that reads as independent often has one buried fork (which of two file formats, which edge case counts).Walk the steps out loud first, and if any need a call only you can make, either decide it in the brief up front or keep the task in chat.
The output is verifiable. You can look at the result and know, within a few minutes, whether it is correct. A generated changelog you can diff against the commits is verifiable. A strategic recommendation that might only prove wrong in three months is not.Common gotchaThe trap is calling a task verifiable when you can only verify it looks plausible, not that it is right. Cowork fills gaps with confident-sounding output, so a quick skim often passes a wrong answer.Before you hand it off, decide what concrete check (a diff, a test, a known correct value) will tell you it is correct, and if you cannot name one, keep the task in chat.
When all three are true, Cowork is strictly better than a chat session: it runs without your attention and you come back to a done artifact.
What tasks should I not use Claude Cowork for?
Exploratory work. When you do not know exactly what you want yet, you need back-and-forth. Asking "help me rethink how we structure our onboarding docs" is a conversation, not a task. The value comes from the exchange, not the artifact.
Ambiguous inputs. If the source material is messy, contradictory, or requires judgment calls about what to include, you will need to guide those decisions in real time. Cowork will make plausible choices, but they will often be the wrong ones for your situation.
High-stakes first drafts. When the output will go directly to a client, executive, or public channel with minimal review, keep yourself in the loop. The cost of a subtle error is high enough that the interactive review cycle is worth it.
Novel task types. The first time you do something, stay in the conversation. Work out the right output format, the right level of detail, and the right constraints interactively. Once you have a proven pattern, convert it to a Cowork brief and automate it.
Work that needs context you have not written down. Cowork only knows what you put in the brief and the project context. If the task requires implicit knowledge you carry in your head, you either need to write it down first (which often clarifies the task enough to hand it off) or stay in chat where you can supply context on the fly.
Decision table
Use this as a quick reference. If your task matches the left column, prefer Cowork. If it matches the right, stay in chat.
| Dimension | Use Cowork | Stay in chat |
|---|---|---|
| Goal clarity | Defined before you start | Still being figured out |
| Inputs | Fixed, referenced by path | Evolving or partial |
| Mid-task decisions | None expected | Likely needed |
| Output format | Already known | To be determined |
| Verifiability | Fast to check on return | Hard to evaluate |
| Stakes of error | Low to medium | High or irreversible |
| Prior runs | Proven pattern exists | First time doing this |
| Context required | Written down in brief/project | Still in your head |
A rough heuristic: if you would feel comfortable leaving for two hours while a capable contractor handled it, hand it off to Cowork. If you would stay nearby to answer questions, keep the conversation open.
How do I turn a chat session into a Cowork task?
Many tasks start as chat sessions and graduate to Cowork tasks. That path is intentional.
The first run of any new task should be interactive. You learn the failure modes, discover the implicit constraints you forgot to write down, and produce the first example of a good output. That example becomes the template for the brief.
Once a brief is stable, identical work that used to take thirty minutes of your attention runs without you.
How do I review Claude Cowork output?
Returning to a finished Cowork task is not the same as finishing the work. Your job shifts from producer to editor. That is a faster mode, but it still requires attention. For the full workflow, see review and merge what Claude Cowork builds.
A few habits that keep the review step honest:
Review against the brief, not just your intuition. Open the brief alongside the output. Check each constraint explicitly. Intuition drift is real: if you have been away for two hours, your memory of what you asked for is fuzzy.
Spot-check the edges. Cowork is generally reliable in the middle of a task and more likely to slip at the boundaries. Did it write to the correct file path? Did it stop at the scope limit? Did it avoid the things you told it to avoid?
Look for confident errors. An async agent cannot express uncertainty the way a chat session can. When it hits a gap, it fills it plausibly. Plausible is not always correct. Flag anything that looks like an extrapolation.
Keep a note of recurring failure modes. Every time you find something wrong, ask whether a brief change would prevent it. Add a "do not" clause. After two or three iterations, most briefs become stable.
What this looks like in practice
Suppose you run a weekly digest of engineering updates for your team.
The first time, you do it in chat. You iterate on the format, figure out which sources to pull from, decide how long it should be, and produce one example that the team likes.
The second time, you write a Cowork brief based on what you learned. You run it, review it, fix two things the brief missed, and update the brief.
By the third or fourth run, the brief is stable. You schedule it. Every Friday, Cowork pulls the updates, formats the digest, and saves it to the right folder. You spend five minutes reviewing instead of thirty minutes writing.
That is the return Cowork is designed to deliver. But it only materialises if you invested the interactive sessions upfront to learn what correct looks like.
When the line blurs
Some tasks are scoped but high-stakes. Some are well-defined but novel. In those cases, a middle path works: run Cowork as a first-draft engine and treat the output as a starting point for a focused chat session.
This uses Cowork for the mechanical assembly and the chat session for quality control. It is slower than pure async but faster than doing the whole thing in chat from scratch.
The short version
Cowork earns its place when the task is scoped, independent, and verifiable. It is the wrong tool when you are still figuring out what you want, when mid-task decisions are likely, or when the cost of a quiet error is high.
Start in chat. Convert to Cowork when the pattern is proven. Review output against the brief, not just instinct. Build a library of stable briefs for work you repeat.
For how to write a brief that gives Cowork what it needs, see How to brief Claude Cowork for good results. For how async tasks connect into larger systems, see How Agents Fan Out.