Anthropic Academy — 15 lessons · ~115 min total · Free
Notes taken directly from the course via Chrome. All content from actual lesson pages.
Module 1 — Meet Claude Cowork
Lesson 1 · What is Claude Cowork (8 min)
Core mental model: Cowork is about delegating, not just chatting.
- Chat = turn-by-turn dialogue. You ask, Claude responds. You stitch the steps together.
- Cowork = a working session. You describe an outcome, Claude plans and executes the whole arc end-to-end.
- Code = a full development environment inside your codebase, with terminal and git access. For developers only.
What makes a great Cowork task — the anatomy:
- Local files + multiple tools + multiple steps + a real deliverable as output
- Example: “Look across the Q3 Sales folder, my emails, the leadership Slack, and the proposal decks — pull it together and write me a one-page summary for the exec team.”
How Cowork works in your environment:
- On your files — reads the folder you point it at, writes finished outputs back
- In your apps — pulls context from email, calendar, Slack, Drive, CRM via connectors
- In your browser — Claude in Chrome reads and acts on pages (dashboards, portals, logins)
- With your tools — takes action, not just describes what to do
The key shift for new users: Most people’s instinct from Chat is to type a question, see what comes back, iterate. That works in Cowork too — but you get the most from it when you hand Claude an entire piece of work, not just a question.
Lesson 2 · Setting up Claude Cowork (8 min)
Install: Claude Desktop from claude.com/download. Find Cowork in the mode selector (top-right). Requires paid plan.
Pointing Claude at a folder:
- Click Work in a project → pick a folder on your computer
- That folder is where the work lives — Claude reads every file inside and saves outputs back
- Pick the smallest folder that holds what the task needs — not Documents, not Desktop
- The folder is the only place Claude has read AND write access
- Cloud files (Google Drive, M365) are often read-and-search only via connectors — local folder is most reliable for building and iterating
Connectors — what to set up first:
| Connector | Best for |
|---|---|
| Email + Calendar (Gmail / Outlook M365) | Context from meetings, drafting follow-ups, finding past threads |
| Messaging (Slack / Teams) | Searching channel history, synthesizing team discussions |
| Cloud storage (Drive, SharePoint, Box) | Docs that don’t live on your local machine |
| CRM + project tools (Notion, Salesforce, Asana, etc.) | Real data where your team operates |
Once a connector is on, reference it naturally: “Check what the team said in Slack about the launch.”
For tools without a connector (internal dashboards, web apps behind a login) → Claude in Chrome is the bridge. Covered in Module 3.
Permission modes:
| Mode | Behaviour | When to use |
|---|---|---|
| Ask before acting (default) | Claude pauses for your approval before each action (send, share, delete) | New tools, unfamiliar files, anything you want to watch closely |
| Act without asking | Claude works without pausing | Only when actively supervising + working with trusted files |
In both modes: Claude always asks before permanently deleting a file. This cannot be skipped.
Getting started exercise: Point Claude at a real folder → connect one app → ask Claude to “take a look at everything in this folder and write me a brief on what you’ve learned.” Review the brief against your own knowledge.
Lesson 3 · What Claude Cowork can do for you (11 min)
Three patterns of work that suit Cowork:
Pattern 1 — Multi-step tasks If a task requires several steps (gather → compare → draft → format), hand the whole arc to Claude in one prompt.
- Example: Triage a week of customer-feedback emails into themes, with example quotes for each
- Example: Pull figures from three reports and a spreadsheet, assemble into one dashboard
Pattern 2 — File-based tasks The objective is a real artifact (Word doc, spreadsheet, deck, PDF) and the inputs are real files Claude reads, edits, and saves back.
- Example: A formatted client proposal from your standard template + meeting notes
- Example: A monthly metrics report assembled from raw spreadsheets, with charts
Pattern 3 — Multi-tool tasks The work touches Gmail, Slack, M365, your calendar, your CRM. Cowork plans across all of them and runs the whole sequence as one delegation — instead of you stitching steps together prompt by prompt.
- Example: Draft follow-up emails in Outlook after a meeting, using the calendar invite, attendee list, and meeting notes
- Example: Search Slack for everything said about a launch, synthesize into an update
Scheduled tasks:
- Type
/schedulein any Cowork task → describe the task and cadence → Claude drafts a prompt for review - Or: do the task once, confirm the output looks right, then type
/scheduleto make it recurring - Cadence options: hourly, daily, weekdays, manual
- ⚠️ Only runs when your computer is on and Claude Desktop is open
Dispatch (send tasks from phone):
- Start a Cowork task from the Claude mobile app while away from your desk
- Work runs on your desktop — same files, same connectors, same permissions
- Push notification when done
- Currently in research preview on Pro and Max plans only
Lesson 4 · Hand Claude Cowork your first task (15 min)
A good Cowork prompt does three things:
- Names the deliverable — “a one-page brief,” “a slide for the QBR,” “a ranked list with notes.” Specifics about format and length save you a regeneration.
- Names the inputs — which folder, which channels, which date range, which app
- Names the nuances — the context Claude can’t guess: “I want base, best, and worst case scenarios that account for the 3 new locations we opened in Q3.”
If you leave a piece out, Cowork will usually ask you for it in a clarifying question.
The clarifying question step:
- Claude asks to close context gaps before the work starts, not during
- Most questions are easy: Claude presents options, you pick the one that fits
- This is different from Chat — the back-and-forth happens upfront, not across five rounds of “actually can you also…”
Steering mid-task:
- Watch the progress panel — Claude shows you its plan and each step as it runs
- If Claude is heading in the wrong direction: interrupt. Don’t wait for it to finish.
- You can also stop the run, refine the prompt, and restart with what you’ve learned
- Redirect cost is low. Cowork is built for course corrections.
Reviewing the finished deliverable:
- The file is in your folder — open and review it the way you’d review a colleague’s draft
- Check: Does it meet the actual objective? Are facts accurate? Does anything seem made up?
- If mostly right → tell Claude what to change rather than starting over
- If wrong in a load-bearing way → the prompt was missing load-bearing context. Add it and ask Claude to adjust.
Module 2 — Make Claude Cowork Yours
Lesson 5 · Get better results faster (5 min)
The four building blocks that make Cowork compound:
| Building block | What Cowork learns | What that unlocks |
|---|---|---|
| Global instructions | Who you are and how you work | Every task starts calibrated to your role, formats, preferences |
| Projects | The context of one stream of work | Cowork works like someone already on the team |
| Skills | How a specific process should be done | Cowork runs it the way your team would — your templates, your steps |
| Plugins | The expertise of your role or field | Cowork goes from generalist to specialist |
They’re independent and they compound. Don’t try to set all four up on Day 1 — let them emerge naturally from your work.
Lesson 6 · Standing context: Global instructions and projects (7 min)
Global instructions — the brief that applies to every session:
- Written once in Settings → Cowork → Edit Global instructions
- Claude references them during every session, every scheduled task, every Dispatch
- What to put in: who you are and what you do; shorthand/acronyms you use; how you like output delivered (format, length, tone)
- Don’t try to make them perfect on Day 1 — they improve as you notice corrections you keep giving Claude
Starter template:
“I’m a [role] at [company], working on [main 1–2 streams of work]. Common acronyms: [list]. Most of my deliverables are [docs/decks/briefs/models]. Lead with the recommendation, keep background to one paragraph.”
Projects — a scoped workspace for a stream of work:
A project has four components:
- Instructions — like global instructions, but scoped to this project
- Scheduled tasks — recurring runs that belong to the project and run with its context
- Context — one or more folders or links Claude works from inside every conversation
- Memory — what Claude learns from conversations inside the project (builds automatically — you don’t write it)
Outside a project, each session starts fresh (apart from global instructions). Inside one, every conversation adds to what Claude knows — so the next task opens with the client’s situation, last week’s decisions, and what’s still open, already in hand.
Streams of work that suit a project:
- A client or account (folder of notes + standing instructions)
- A recurring deliverable (monthly report, weekly leadership update — each cycle builds on the last)
- A launch or initiative (briefs, decisions, status updates — the whole thread until it ships)
Three ways to start a project:
- From scratch — start empty, add instructions and context as you go
- From an existing folder — point it at a folder you already work out of
- From a Chat project — transition instructions and knowledge over (one-way only; changes don’t sync back to Chat)
Create via: Cowork sidebar → Projects → New project.
Lesson 7 · Skills: Teach Claude Cowork your way (12 min)
What a skill is: A reusable playbook — a folder of files and resources — that teaches Claude how to do a specific kind of work the way you’d want it done.
How skills are triggered: Claude notices when a task matches a skill you have installed and loads it automatically. You can also be explicit: “Use the board memo drafting skill.”
The four components of a skill:
| Component | What it is | Purpose |
|---|---|---|
| SKILL.md | The instruction file | Tells Claude what the skill does, when to use it, and how to do it — like a runbook for a new colleague |
| Assets | Logos, brand templates, slide masters, fonts | Raw materials the skill uses to produce real-looking output |
| References | Examples of good output, style guides, clause libraries | Shows Claude what “good” looks like for this kind of work |
| Scripts | Small pieces of code Claude can run | Handles the parts that should happen the same way every time (variance calculation, chart formatter, etc.) |
A skill can use any combination — some are just a SKILL.md, others use all four. Include what’s needed, nothing more.
Building a skill with Claude: Start a new Cowork conversation and say:
“I want to build a skill for [the recurring process you’re tired of re-explaining]. Walk me through what you need to know.”
Claude will ask what the skill should do, when it triggers, what good output looks like, and what resources to use. Answer specifically — point at real examples, real templates, real prior outputs.
To update an installed skill, just give Claude the correction: “Add a step that flags any deal over $100K that slipped two stages.”
Skill candidate test: Think of one process you repeat — a report you run, a format you always use, a checklist you follow. That’s your first skill.
Lesson 8 · Plugins: Encode your team’s expertise (12 min)
What a plugin is: A packaged set of skills built around a job. Where a skill is one playbook, a plugin is several — skills + the connectors and subagents they depend on.
A subagent is a purpose-built helper a skill can spin up to handle one part of the work in its own context (e.g. a research subagent for a research step, a drafting subagent for a drafting step).
Two shapes plugins take:
Shape 1 — End-to-end process bundled together Sequential steps packaged so the whole process runs as one. Example: a monthly-close plugin with separate skills for pulling actuals, building the variance table, and drafting the board memo.
Shape 2 — Team’s most-used skills bundled together A set of recurring jobs, not sequential — just the skills the team reaches for most. Example: a finance plugin with separate skills for variance analysis, financial modeling, investment-memo drafting, and quarterly reports.
Installing from the Anthropic marketplace:
- Anthropic publishes plugins for common roles: finance, legal, sales, marketing, customer support, product management, and more
- Customize → Plugins → browse → Install → approve connectors → skills available immediately
Customizing a plugin:
- Customize → Plugins → [Plugin name] → Customize
- Opens a Cowork task where you work with Claude to tailor the plugin to your team’s templates and workflows
- Example: “Here are our last three red-lined NDAs. Update the /nda-triage skill so the format and tone match these.”
Building your own plugin: Ask Cowork to bundle the workflow — it packages the skills, includes connectors, and prepares it for installation.
Quickstart: Type /setup-cowork in any new Cowork conversation. Claude runs a short interview and recommends the plugin that fits your role.
Module 3 — Use Claude Wherever You Work
Lesson 9 · Claude in Chrome (10 min)
What it unlocks: Claude in Chrome is the bridge for tools that don’t have a connector. Anything in a browser — dashboards, portals, web apps behind a login — becomes accessible.
Real work examples:
- Internal dashboards — Tableau, Looker, BI tools. Claude pulls the numbers and hands the data to Cowork.
- Vendor portals and customer systems — procurement portals, CRMs behind SSO, customer support tools. Claude navigates, pulls what you need, acts on it.
- Web apps behind a login — anything with a browser interface becomes scriptable.
- Web research → deliverable — open ten tabs, pull what’s on each, turn into a brief. No copy-paste.
How it works with Cowork: Claude in Chrome and Cowork work in one conversation. Claude gathers info and takes actions in the browser; Cowork uses the results to build the deliverable. One delegation, multiple sources.
Watch-outs:
- You need to be already signed in — Claude cannot sign in to tools for you
- Be deliberate about web access — Claude sees what you see, including everything you have access to
- For sensitive sites: narrow what Claude can act on, review actions before approving
Lesson 10 · Claude for Microsoft 365 (5 min)
What it is: Claude as an add-in inside Word, Excel, PowerPoint, and Outlook — working on the files you have open.
What Claude does in each app:
| App | Strongest move |
|---|---|
| Excel | Pull actuals from Q3 sheet, compare to Q3 plan, write variance commentary in column F |
| PowerPoint | Read your slide master → build slides that match → generate native editable charts (not pasted images) |
| Word | Draft, revise, reformat in place; work with tracked changes and comments; pull from connected sources |
| Outlook | Triage incoming mail with context from your broader work; draft replies that reflect prior threads |
The cross-app workflow (one conversation carries context across all four):
- Outlook → Word: Brief lands in inbox → “Open in Word and start the memo from our firm template” → Word opens with email thread already loaded
- Word → Excel: “Build the market-sizing model behind option 2” → Excel opens, pulls assumptions from the Word doc, builds a multi-tab model
- Excel → PowerPoint: “Turn this into the steering-committee deck in the client template” → native editable charts in your slide master
- Back to Outlook: “Find 30 minutes with the team before Thursday” → invite drafts and waits for you to click Send
When to use M365 vs Cowork:
- Cowork → when the work pulls from many sources and ends in a deliverable (building from scratch, running workflows on a schedule)
- Claude in M365 → when you’re working in the Office files themselves, refining in place, carrying context from one app to the next
- Most real work uses both — Cowork builds the first draft, you refine it with Claude inside the app.
Module 4 — Sharing and Safety in Claude Cowork
Lesson 11 · Best practices for working safely (8 min)
Set up so mistakes can’t reach what matters:
- Use a dedicated working folder, not a catch-all. Make a folder for the work, move in what’s needed. Pointing Claude at Documents or Desktop = letting a new colleague rummage through every file you have.
- Back up anything irreplaceable before you start. Claude won’t delete without asking — but the cost of clicking through the wrong confirmation is the cost of the file. Cloud backup, a separate folder, a disconnected drive.
- Test new workflows on copies first. Especially scheduled tasks — run the first time against a copy of the data, confirm it behaves, then point at the live folder.
Write prompts that leave no room for the wrong action:
- Be specific about destructive verbs. “Cut the section” is ambiguous. Name what you mean: “Remove the section from the draft, but keep the file.”
- Name the bounds. “Only the 3 most recently updated files.” “Don’t message anyone — draft only.” This gives you a clear line for spotting drift.
- Use scheduled tasks for drafts initially. Until you’re confident a task runs as intended, prompt it to draft for your review rather than send on your behalf.
Three in-the-moment checks:
- Read the plan. When Claude starts a task it lays out what it’s going to do. Skim it — does the plan make sense? Right sources? Right order? Redirect if not.
- Watch for unexpected patterns. If Claude is touching files or sites you didn’t mention, or scope is creeping — stop the task. “Something feels off” is a real signal.
- Approve confirmation prompts deliberately. Most mistakes happen not because safeguards failed, but because someone clicked through a confirmation that wasn’t the action they intended. Read the dialog.
When Cowork is NOT the right tool:
- Regulated workflows that need an audit trail (Cowork activity isn’t in the Compliance API)
- Anything you wouldn’t trust a smart colleague to do unsupervised (sending legal docs to counterparties, pushing customer-facing changes)
- Highly sensitive personal data outside what your IT team has explicitly approved
Lesson 12 · Validating skills for plugins (8 min)
Why evals matter: When you share a skill, teammates don’t have your workarounds. They might phrase the request differently, hand it different inputs, or hit an edge case. Evals catch those stumbles before someone else does.
What an eval actually is: A try-out. A realistic request goes in, you look at what comes out, and you tell Claude what to fix. No code, no test scripts — just your judgment about whether the result is good enough to put your name on.
How the eval system works (via skill-creator):
- Skill-creator generates two or more realistic prompts someone might use with your skill
- For each prompt it produces a pair of outputs: with-skill vs without-skill
- The without-skill output is the comparison point — you see what difference your skill is actually making
How to give feedback:
- Is the skill version the one I’d use? If yes — note what made it better so the skill keeps doing that.
- If not — what’s missing or off? Be specific: “The tone is too formal” or “it skipped the executive summary” gives Claude something to act on.
The iteration loop:
- Submit feedback → Claude updates the skill → run the same prompts again to check
- Change one thing at a time so you can tell what actually moved the needle
- Most skills are ready after one or two rounds
- The bar: cases you care about pass meaningfully better than baseline — not perfect evals
If outputs already look great on the first pass? You’re done. Evals aren’t a hoop — they’re for when you need confidence.
Lesson 13 · Share what you build with your team (7 min)
Distributing a plugin in your organization: Bundle skills into a plugin (Lesson 8), then hand it to whoever manages your org’s private marketplace (team lead, enablement/ops owner, or IT). They publish it with one of these install levels:
| Level | Behaviour |
|---|---|
| Available | Appears in the company Directory; people install if they want it |
| Installed by default | Already on when teammates open Cowork; they can turn it off |
| Required | Installed and stays on — for compliance or must-run-the-same-way work |
| Hidden | In marketplace but not shown in Directory — for staging or restricted rollouts |
Teammates see the plugin in their Directory labeled as from your company. They can use it and turn it off (unless required), but can’t edit it — updates flow from whoever maintains it.
Habits for keeping a shared plugin healthy:
- One owner — every shared plugin has a named person who reviews changes, runs evals after edits, and decides when to update or retire
- Evals before every publish — treat the eval loop as the gate; if the cases you care about don’t hold up after a change, don’t push it to everyone
- Name skills and plugins specifically — “meeting-prep” will collide with other plugins; “sales-customer-renewal-prep” won’t
- Set a review rhythm — quarterly: look at what’s installed, what’s getting used, what’s gone stale. Retire what nobody runs.
Lesson 14 · Wrap up and next steps (5 min)
The throughline of the entire course:
Cowork goes beyond chat to allow you to delegate real work. Everything else in the course builds on that.
Your first-week action list (pick one):
- Write a five-sentence global instructions block, or create a project for a stream of work you’re already in
- Take a recurring deliverable and put it on a schedule (
/schedule), or set up Dispatch for off-hours tasking - Go to Customize → Plugins, install the plugin closest to your role, run it against this week’s work
- Try Claude in Chrome or Claude for M365 on one task in whichever surface your real work lives
- Share a use case, workflow, or skill you’ve built with your team
Related Anthropic Academy courses:
- AI Fluency: Framework & Foundations — prompting, evaluating output, knowing when AI is and isn’t the right tool
- AI Capabilities and Limitations — deeper survey of what generative AI can do across modalities
- Claude 101 — companion course on using Claude across all surfaces
Quick Reference
Launch Cowork: Claude Desktop → mode selector → Cowork
Point at a folder: Prompt bar → Work in a project → pick folder
Set global instructions: Settings → Cowork → Edit Global instructions
Create a project: Cowork sidebar → Projects → New project
Schedule a task: Type /schedule in any Cowork task
Find + install plugins: Customize → Plugins
Customize a plugin: Customize → Plugins → [name] → Customize
Plugin setup wizard: Type /setup-cowork in a new conversation
Dispatch (mobile): Start task in Claude mobile app → runs on desktop
Key Concepts Cheatsheet
| Term | Definition |
|---|---|
| Cowork | A mode of Claude inside the Desktop app where Claude works on tasks alongside you — delegating, not chatting |
| Connector | An integration that links Claude to an app (Gmail, Slack, Salesforce, etc.) |
| Skill | A reusable playbook folder that teaches Claude how to do a specific process your way |
| Plugin | A bundle of skills + connectors + subagents built around a job or role |
| Subagent | A purpose-built helper a skill can spin up to handle one part of the work in its own context |
| Project | A scoped workspace tied to one stream of work, with memory that builds across conversations |
| Global instructions | A standing brief in Settings that applies to every Cowork session |
| Eval | A lightweight test: realistic prompts go in, you judge whether the with-skill output beats the without-skill baseline |
| Dispatch | Starting a Cowork task from your phone while the work runs on your desktop |
| Scheduled task | A task set to run on a recurring cadence or on demand |
Source: Introduction to Claude Cowork — Anthropic Academy · All 15 lessons read directly via Claude in Chrome · 2026-05-16