▲ Claude Academy
Sign in

Vault note

Course: Introduction to Claude Cowork

Mirrors: Anthropic Academy — Introduction to Claude Cowork · https://anthropic.skilljar.com/introduction-to-claude-cowork Audience: Everyone. Light-technical; no coding required. · Time: ~60 min + project Prereqs: A claude.ai account and claude-101. · Backing notes: claude-ai-features, claude-overview Project: p04-cowork-workspace

Chat answers questions. Cowork does work. By the end of this course you can hand Claude a real, multi-step task in a Cowork workspace, watch it use your files and connectors to actually carry the task out, supervise the steps it takes, and decide when Cowork is the right tool versus a plain chat or Claude Code.

Learning objectives

After this course you can:

  • Explain what Cowork is and how it differs from a chat conversation.
  • Delegate a concrete, multi-step task to Cowork and read its execution plan.
  • Supervise a run: pause, redirect, approve, and review the work it produced.
  • Connect files and integrations (connectors) so Cowork can act on your real material.
  • Choose between Cowork, a chat, and Claude Code for a given job.
  • Apply the 4D ideas of Delegation and Discernment to Cowork specifically.

Module 1 — What Cowork is

🎞 Frame 1 · From answering to doing · ⏱ ~2 min

🎬 Scene — Split screen. On the left, a chat returns a paragraph of advice. On the right, a Cowork workspace opens spreadsheets, drafts an email, and checks items off a list — by itself.

🧠 Concept — Cowork is a surface where Claude works alongside you on a real task inside a persistent workspace. Instead of just describing how to do something, it executes the steps — reading your files, using connectors and tools — and then hands the result back for you to review.

🖼 On screen

ChatCowork
OutputAn answer / a draftCompleted work + the steps taken
ScopeOne turn at a timeA multi-step task, start to finish
Acts on toolsOnly if you wire one upFiles & connectors, as part of the job
Your roleAsk & copy outDelegate, supervise, review

✅ Checkpoint — In one sentence, what does Cowork do that a normal chat does not?

🎞 Frame 2 · The workspace · ⏱ ~2 min

🎬 Scene — A panel that holds the task, the files in play, a running list of steps, and the artifacts produced so far — all in one place that persists.

🧠 Concept — A Cowork workspace is the shared room where the task lives. It keeps the goal, the connected sources, the plan of steps, and the outputs together, so a long task doesn't lose its thread between turns. (Think of it as a Project that can act, not just remember.)

🖼 On screen

Workspace: "Q3 board update"
  ├─ Task:        Compile a 1-page board summary from the Q3 numbers
  ├─ Sources:     finance.xlsx · Drive folder · last quarter's deck
  ├─ Steps:       [✓] pull numbers  [✓] compute deltas  [→] draft summary
  └─ Outputs:     board-summary.md  (review before sending)

✅ Checkpoint — Name the four things a workspace keeps together.

🎞 Frame 3 · Execute, then you review · ⏱ ~2 min

🎬 Scene — Claude completes a run and surfaces a "Review" prompt: here's what I did, here's the output, here's what I'd do next.

🧠 Concept — Cowork's loop is delegate → execute → review. Claude does the work and then presents it for your approval. You are the editor and the accountable human, not the typist. Nothing high-stakes happens without you seeing it.

⚠️ Gotcha — "It did the work" is not "the work is correct." The review step is yours to own — Cowork moves the labor, not the responsibility.

✅ Checkpoint — What are the three beats of the Cowork loop?

Module 2 — Delegating a task

🎞 Frame 4 · A good Cowork task ≠ a good chat prompt · ⏱ ~3 min

🎬 Scene — A vague "help with my expenses" gets a clarifying question; a well-scoped task gets a plan and starts running.

🧠 Concept — Delegation is the first competency of AI Fluency's 4D framework. A delegable task names a clear outcome, the inputs to use, and the boundary of what's in scope. Cowork can pursue a goal across many steps, so the brief matters more than in a one-shot chat.

🖼 On screen

❌ "Sort out my receipts."
✅ "From the receipts in this Drive folder, build a spreadsheet
    with date, vendor, amount, and category. Flag anything over
    $200 for my review. Don't submit anything — just prepare it."

✅ Checkpoint — Rewrite "plan my trip" into a delegable Cowork task with an outcome, inputs, and a boundary.

🎞 Frame 5 · Reading the plan before it runs · ⏱ ~2 min

🎬 Scene — Before touching anything, Cowork shows a numbered plan: 1) read folder, 2) extract fields, 3) build sheet, 4) flag outliers. The user nudges step 4 and approves.

🧠 Concept — Cowork proposes a plan of steps you can inspect and edit before execution — the everyone-friendly cousin of plan mode. Catching a misread here costs seconds; catching it after a 12-step run costs a redo.

🖼 On screen

Proposed plan:
  1. Open the "Receipts/Q2" Drive folder
  2. Extract date · vendor · amount · category from each file
  3. Write rows into a new "Q2 Expenses" sheet
  4. Highlight rows where amount > $200      ← you can edit this
  [ Approve ]  [ Edit plan ]  [ Cancel ]

✅ Checkpoint — Why is editing the plan cheaper than fixing the result afterward?

🎞 Frame 6 · Knowing what NOT to delegate · ⏱ ~2 min

🎬 Scene — A card sorts tasks into "good to delegate" and "keep on a human."

🧠 Concept — Delegate tasks that are bounded, checkable, and reversible. Keep — or tightly supervise — anything irreversible, high-stakes, or requiring your judgment/relationships (sending the actual email to a client, paying an invoice, deleting data).

🖼 On screen

Great to delegateKeep a hand on
Collate, summarize, reformatFinal send to a customer
Draft a first versionSpending money / payments
Cross-check two filesDeleting or overwriting data
Prepare a report for reviewAnything you can't undo

✅ Checkpoint — Give one task you'd happily delegate and one you'd never fully hand off.

Module 3 — Supervising and connecting

🎞 Frame 7 · Supervise while it works · ⏱ ~3 min

🎬 Scene — Mid-run, the user watches steps tick by, pauses on step 3, types "use last year's categories instead," and resumes.

🧠 Concept — Cowork is interruptible. You can pause, redirect with a new instruction, approve a sensitive step, or stop a run. Supervising is active, not "fire and forget" — you stay in the loop for the moments that matter.

🖼 On screen

Running… step 3 of 5: drafting summary
  > pause
  You: Use last year's category names, not new ones.
  Claude: Got it — re-categorizing with the FY24 labels. Resuming.

✅ Checkpoint — Name two ways you can intervene during a run without restarting it.

🎞 Frame 8 · Connectors & integrations · ⏱ ~3 min

🎬 Scene — A connectors panel lights up: Google Drive, Gmail, Calendar, Slack. Cowork now reads a doc and proposes a calendar invite.

🧠 Concept — Connectors (built on MCP) plug Cowork into your real tools and data — Drive, Gmail, Calendar, and more — so it can use your material instead of working from memory. You grant access per connector, and Cowork acts within that scope.

🖼 On screen

Connectors enabled for this workspace:
  ✓ Google Drive   (read files)
  ✓ Calendar       (suggest events — confirm before creating)
  ✓ Gmail          (draft only — never auto-send)

⚠️ Gotcha — Connectors give Cowork reach into real accounts. Grant the minimum needed, and prefer "draft / suggest" over "auto-send" for anything that leaves your hands.

✅ Checkpoint — Why does connecting a source make Cowork's output more trustworthy than asking from memory?

🎞 Frame 9 · Review the work, not just the answer · ⏱ ~2 min

🎬 Scene — The run finishes. Cowork shows the output and the trail: which files it read, which steps it took, what it changed.

🧠 Concept — This is Discernment (4D again): evaluate the output, the process, and the behavior. Because Cowork shows its steps and sources, you can spot a wrong assumption or a skipped file — not just typos in the final draft.

🖼 On screen

Review checklist
  □ Output:   does the summary say what's true?
  □ Process:  did it use the right folder / the right quarter?
  □ Behavior: did it stay in scope (didn't send anything)?

✅ Checkpoint — Discernment asks you to check which three things about a Cowork run?

Module 4 — Cowork, chat, or Claude Code?

🎞 Frame 10 · When Cowork shines · ⏱ ~2 min

🎬 Scene — A montage of multi-step, tool-touching jobs: reconcile two spreadsheets, prep a weekly report from Drive + email, triage a backlog.

🧠 Concept — Reach for Cowork when a task is multi-step, touches your files or connectors, and benefits from execution you then review. It's the surface for "do this whole thing for me, and show your work."

🖼 On screen

Cowork is the fit when the task…
  • spans several steps to a finished deliverable
  • needs your real files / accounts (via connectors)
  • is bounded and checkable (you'll review the result)

✅ Checkpoint — Describe a task from your own week that fits all three bullets.

🎞 Frame 11 · Cowork vs. chat vs. Claude Code · ⏱ ~3 min

🎬 Scene — Three doors labeled Chat, Cowork, Claude Code. A signpost points each kind of task to the right door.

🧠 Concept — Same model family, three surfaces, different jobs. Match the surface to the work, not the other way around. (Surfaces overview: claude-overview.)

🖼 On screen

Use…When the job is…Example
ChatThinking, drafting, Q&A — one turn at a time"Explain this clause." "Draft a tweet."
CoworkA multi-step task over your files/connectors"Build the expense sheet and flag outliers."
Claude CodeWorking in a code repository in your terminal/IDE"Add tests and fix the failing build."

⚠️ Gotcha — Don't force a coding repo task into Cowork, or a quick rewrite into a full Cowork run. Wrong door = more friction, not less.

✅ Checkpoint — Pick the surface: (a) "summarize this PDF," (b) "reconcile these two invoices in Drive," (c) "refactor the auth module."

🎞 Frame 12 · You can delegate now · ⏱ ~1 min

🎬 Scene — Recap slide: delegate a scoped task → review the plan → supervise → connect sources → review output → pick the right surface.

🧠 Concept — You can now hand Cowork a real task and stay the accountable human over it. Next, deepen the mindset behind it in ai-fluency-framework-foundations.

✅ Checkpoint — Without looking, list the three beats of the Cowork loop and the three surfaces from Frame 11.

🛠 Project

Complete p04-cowork-workspace — Your First Cowork Workspace. You'll connect at least one source, delegate a genuinely multi-step task (e.g., compile a report from a folder), review the plan before it runs, supervise one redirect mid-run, and write a short before/after of what you reviewed and changed.

🧪 Self-check quiz

  1. What is the core difference between Cowork and a chat conversation?
  2. Name the three beats of the Cowork loop.
  3. What four things does a Cowork workspace keep together?
  4. Give the three properties of a task that's safe to delegate.
  5. What is a connector, and what is it built on?
  6. Discernment asks you to evaluate which three aspects of a run?
  7. You need to refactor code in a Git repo — Cowork, chat, or Claude Code?
<details><summary>Answers</summary>
  1. Cowork executes a multi-step task and then presents it for review; a chat only returns an answer. 2. Delegate → execute → review. 3. The task/goal, connected sources, the plan of steps, and the outputs. 4. Bounded, checkable, reversible. 5. An integration plugging Cowork into your real tools/data (Drive, Gmail, etc.), built on MCP. 6. Output, process, behavior. 7. Claude Code.
</details>

🎓 Certificate criteria

You've "passed" Introduction to Claude Cowork when you can:

  • Delegate a multi-step task with a clear outcome, inputs, and boundary.
  • Review and edit a proposed plan before execution.
  • Supervise a run — pause, redirect, and approve a sensitive step.
  • Connect at least one source and explain least-privilege access.
  • State when you'd choose Cowork vs. chat vs. Claude Code.
  • Complete p04-cowork-workspace and journal one thing your review caught.

Tick this course off in progress and record the date you earned Anthropic's official Cowork certificate.

🔗 Sources & deeper notes