What Anthropic teaches in this course
Cowork is described in Lesson 1 as built on the same architecture as Claude Code, the agentic system used to write and ship production software, but retargeted at knowledge work. The shift the course frames is from conversation to delegation. In chat, you ask a question and get text back; you still move information between tools, assemble the output, and handle the steps in between. In Cowork, you describe an outcome, Claude plans it, works through it, and delivers a finished file to your drive. Three things enable the loop: Plan (review before work starts), Execute (long-running work in an isolated environment), and Connect (reach the systems where your work already lives).
The load-bearing lesson is Lesson 3, The Task Loop. The pattern is four steps you will repeat for every task: (1) describe what to look at, what you want back, and where it should go; (2) answer a few follow-up questions Cowork asks before it starts; (3) step away or steer (a progress panel shows each step, and you can type in chat to redirect at any point); (4) open the finished file. The course's framing for the output is precise: treat the result as a draft, the way you'd read a first pass from a capable colleague. Cowork's confidence is the same whether the work is right or wrong; your review catches the difference.
Cowork tasks start fresh by default; the way context carries across sessions is projects (Lesson 4). A Cowork project is a named workspace backed by a real folder on your machine, with persistent Instructions and memory. The Instructions panel takes shorthand-style context: who's involved (Rachel is head of product), where things live (contracts in ./Contracts, archive in Drive /old-reports), output preferences (drafts in .docx, finals in PDF), project-specific rules. A few lines is enough. Once Cowork knows the people and the file layout, send this to Rachel and file it where the Q3 report went start meaning specific things. Global instructions handle preferences that don't change between projects.
Plugins (Lesson 5) are the domain-specialist surface. A plugin bundles skills, connectors, and workflows for a function (sales, finance, research, legal) so Cowork approaches your task the way a domain specialist would, not a generalist. Scheduled tasks (Lesson 6) let you run a workflow on a recurring cadence: a Monday-morning research digest, a weekly metrics summary, a quarterly compliance check. File and document tasks (Lesson 7) do real work on real files in real formats: .docx, .xlsx, .pptx, .pdf. The output is a file you open, not text you paste.
Subagents in Cowork (Lesson 8) parallelize independent pieces of a task. The course's example is comparing four vendors: Cowork spins up one subagent per vendor, each researching pricing, integrations, and reviews without the others' material crowding its view, and synthesizes the results into one output. Tasks too large to hold in one conversation get split into pieces that each fit comfortably, and each piece gets focused attention. This is the same hub-and-spoke pattern Claude Code uses, retargeted for knowledge-work parallelism.
Permissions and safety (Lesson 9) is the D5 anchor of the course. Four boundaries shape every session: isolated execution (Cowork runs in a sandboxed environment separate from your OS); controlled file access (you decide which folders Cowork can see; no grant, no access); network policies respected (org rules apply); deletion is gated (permanent deletion always requires explicit approval). The reviewing habit the course pushes hard: open the file, check a number, follow one thread of reasoning. Polished-looking outputs need MORE scrutiny, not less, because Cowork's confidence does not correlate with correctness.
Model selection (Lesson 9) is the practical handle on usage. Claude models come in three tiers: Opus for complex multi-step work (uses the most allocation), Haiku for the quickest and lightest tasks, Sonnet as the everyday default. Match the model to what the task actually needs rather than defaulting to Opus for everything. Three usage-management habits: batch related work (fresh sessions have overhead), use chat for tasks that don't need files or tools (faster and cheaper), monitor where you stand in settings. The Lesson 1 question (does this need my files, my connected tools, or a real output file?) is the same question for both is this a Cowork task? and am I spending my allocation well?
You'll walk away with
- What Cowork is, how it differs from chat (delegation, not conversation), and when each fits the work
- The 4-step task loop: describe what you want back, answer follow-up questions, step away (or steer), open the finished file
- How project-level Instructions and global instructions give Cowork context that carries across every session
- How plugins bundle skills, connectors, and workflows for a specific function (sales, finance, research)
- The permission and safety model: isolated execution, controlled file access, gated deletion, network policy compliance
- How to choose between Opus, Sonnet, and Haiku based on task complexity and usage allocation
11 lessons, with our annotations
6 ideas to carry into practice
Lines worth keeping
Reach for Cowork
When you want a finished file you can open, when the work touches files on your drive or tools you're connected to, when there are many steps or many items to process, or when you want to let it run while you do something else.
Reach for chat
When you want an answer or a draft you'll refine yourself, when everything Claude needs fits in a single paste, or when you want to think turn-by-turn together.
The deciding question
Does this task need to touch your files, your connected tools, or produce a real output file? If yes, Cowork. If no, chat is faster and cheaper.
Isolated execution
Cowork runs in a sandboxed environment on your computer, separate from your operating system. It can't reach what hasn't been granted.
Controlled file access
You decide which folders Cowork can see. No grant, no access. The grant is per-folder, not blanket.
Network policies respected
Cowork follows your organization's network rules. Restricted environments stay restricted.
Deletion is gated
Permanent deletion always requires your explicit approval. You'll always see a prompt first.
How this course shows up on the exam
Direct prep for D5 task statements on appropriate use, human-in-the-loop review, permissions, and model selection. Light D1 overlap on the agentic loop (Cowork shares the Claude Code architecture for non-developer knowledge work).
Blueprint weight15% (D5)Check the pattern
Your agentic loop keeps running after Claude has clearly finished its task. Which control was most likely missed?
Frequently asked
What is Claude Cowork and how is it different from claude.ai chat?
Claude Cowork is built on the same agentic architecture as Claude Code but retargeted at knowledge work. The shift is from conversation to delegation. In chat, you ask and refine text back-and-forth; in Cowork, you describe an outcome and get a finished file (PowerPoint, Excel, Word, PDF) on your drive. Cowork plans the steps, executes in an isolated environment, and connects to the tools where your work already lives.
When should I use Claude Cowork instead of Claude chat?
The deciding question from Lesson 1: does this task need to touch your files, your connected tools, or produce a real output file? If yes, Cowork. If no, chat is faster and uses less of your allocation. Lean toward Cowork when there are many steps or many items, when you want to let it run while you do something else, or when chat ran out of room on a similar task before.
What is the 4-step task loop in Claude Cowork?
Every Cowork task follows the same pattern. (1) Describe what to look at, what you want back, and where it should go. (2) Answer a few follow-up questions Cowork asks before it starts. (3) Step away while it runs, or type in chat to redirect at any point. (4) Open the finished file and review it the way you'd read a first pass from a capable colleague.
How do I give Claude Cowork context that carries across sessions?
Use a project: a named workspace backed by a real folder on your machine, with persistent Instructions and memory. The Instructions panel takes shorthand context: who's involved (Rachel is head of product), where things live (contracts in ./Contracts), output preferences (drafts in .docx, finals in PDF). For preferences that don't change between projects, use global instructions in Settings.
Is Claude Cowork safe to give access to my files and connected tools?
Cowork operates within four explicit boundaries. Isolated execution (sandboxed environment separate from your OS); controlled file access (you decide which folders are visible, per-folder, not blanket); network policies respected (org rules apply); gated deletion (permanent deletion always requires explicit approval). Conversation history stores locally on your machine; check your plan documentation for current audit-logging and compliance details if you have regulated workloads.
Why does my Claude Cowork output look polished but contain errors?
Cowork's confidence is the same whether the work is right or wrong. The more polished an output looks, the more a second look is worth. Polish is a styling artifact, not a correctness signal. The habit Lesson 9 pushes: open the file, check a number, follow one thread of reasoning. Treat every output as a first draft, regardless of how finished it looks.
Should I use Opus, Sonnet, or Haiku for Claude Cowork tasks?
Match the model to the work. Opus for complex multi-step tasks where capability matters most (uses the most allocation). Haiku for quick, light tasks where speed matters most. Sonnet sits in the middle as a sensible default for everyday work. Defaulting to Opus for everything wastes allocation; defaulting to Haiku for everything sacrifices quality where it mattered.
How do plugins in Claude Cowork work and when should I use one?
A plugin bundles skills, connectors, and workflows for a specific function (sales, finance, research, legal) so Cowork approaches your task the way a domain specialist would, not a generalist. Install one when your work is predominantly in that domain and you want consistent specialist behavior across tasks. Plugins are the highest-leverage way to get role-specific quality without writing custom skills yourself.