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
Read these first
Lesson outline
Every lesson from Introduction to Claude Cowork with our one-line simplification. The Skilljar course is the source; we summarize.
| # | Skilljar lesson | Our simplification |
|---|---|---|
| 1 | What is Cowork? | The Claude Code agent architecture retargeted at knowledge work; describe an outcome, get a finished file, not pasted text. |
| 2 | Getting set up | Install the Cowork app, sign in, point it at a folder; that's the first step in any task. |
| 3 | The task loop | 4-step pattern: describe outcome, answer follow-ups, step away or steer, open the file. Repeat for every task. |
| 4 | Giving Cowork context | Projects carry context across sessions; Instructions panel for project rules; global instructions for cross-project preferences. |
| 5 | Plugins: Cowork as a specialist | Plugins bundle skills, connectors, and workflows for a specific function so Cowork approaches your task as a domain specialist. |
| 6 | Scheduled tasks | Run a workflow on a recurring cadence; work you'd otherwise remember to do happens automatically. |
| 7 | File & document tasks | Read, edit, and create real files (.docx, .xlsx, .pptx, .pdf) in your folder; output is a file, not a paste. |
| 8 | Research & analysis at scale | Subagents parallelize independent pieces (e.g., one agent per vendor in a comparison) and synthesize results back. |
| 9 | Permissions, usage, & choosing your model | Isolated execution, gated deletion, network-policy compliance; pick Opus for complex multi-step work, Sonnet for everyday default, Haiku for light tasks. |
| 10 | Troubleshooting & next steps | Common failure modes (wrong folder grant, missing context, runaway tasks) and the next courses in the Cowork sequence. |
| 11 | Quiz on Claude Cowork | 11-question Skilljar quiz; useful self-check on the task loop, plugins, permissions, and model selection. |
The course in 7 paragraphs
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?`
When to reach for Cowork vs chat
The Lesson 1 framing is the cleanest decision rule in the course. Memorize the question.
- 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.
The 4 safety boundaries every Cowork session operates within
Lesson 9 is the D5 anchor. These four are testable.
- 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.
6 takeaways with cross-pillar bridges
Cowork is Claude Code's agent architecture retargeted at knowledge work; the course's framing is the shift from conversation to delegation.
The 4-step task loop (describe outcome, answer follow-ups, step away or steer, open the file) is the pattern for every Cowork task; the result is always a draft, never a final.
Projects with an Instructions panel are how context carries across sessions; a few lines about people, file locations, and output preferences is enough to make shorthand work.
Subagents parallelize independent pieces of a task (one per vendor in a comparison) and synthesize results back; same hub-and-spoke pattern as Claude Code subagents, retargeted for knowledge work.
Cowork's safety boundaries are the D5 exam anchor: isolated execution, controlled file access, network-policy compliance, gated deletion.
Model selection matters for both quality and usage: Opus for complex multi-step, Sonnet for everyday default, Haiku for light tasks. Match the model to the work.
How this maps to the CCA-F exam
3 hand-picked extras
These amplify the Skilljar course beyond what the course itself covers. Each was picked for a specific reason.
Claude Cowork: a research preview
Anthropic's design and purpose write-up; deeper rationale for the conversation-to-delegation shift than the Skilljar lessons abbreviate.
Read source ↗Choosing the right Claude model
The full Opus vs Sonnet vs Haiku tradeoff matrix Lesson 9 abbreviates; pair when you need the per-tier capability and pricing breakdown.
Read source ↗Organize your tasks with projects in Cowork
Canonical reference for project setup, importing from chat projects, and the Instructions panel; expands Lesson 4's brief tour.
Read source ↗Concepts in this course
Agentic loops
What Cowork inherits from Claude Code
Concept: agentic-loops ↗Plan mode
Cowork's plan-then-execute pattern
Concept: plan-mode ↗Subagents
How Cowork parallelizes independent task pieces
Concept: subagents ↗System prompts
What the Instructions panel actually configures
Concept: system-prompts ↗Skills
What plugins bundle for domain specialization
Concept: skills ↗Evaluation
The review-the-output habit Lesson 9 enforces
Concept: evaluation ↗Where you'll see this in production
Claude for operations
Cowork's natural home: knowledge work, recurring tasks, file outputs
Scenario: claude-for-operations ↗Long document processing
Where Cowork's parallel subagents and persistent file output earn their keep
Scenario: long-document-processing ↗Agent Skills for enterprise KM
Plugins as the enterprise-scale specialization surface
Scenario: agent-skills-for-enterprise-km ↗Other course mirrors you may want next
8 questions answered
Phrased as the way real students search. Tagged by intent so you can scan to what you actually need.
DefinitionWhat is Claude Cowork and how is it different from claude.ai chat?
ComparisonWhen should I use Claude Cowork instead of Claude chat?
DefinitionWhat is the 4-step task loop in Claude Cowork?
How-toHow do I give Claude Cowork context that carries across sessions?
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.