Introduction to Claude Cowork — Certification Study Guide

Comprehensive exam preparation for the Anthropic “Introduction to Claude Cowork” course. These notes cover all six modules with practical examples, comparisons, and key concepts for certification success.

Course: Introduction to Claude Cowork Modules: 6 Target: All professionals working with files and documents Difficulty: Beginner to Intermediate

MODULE 1: Meet Claude Cowork

Key Notes

What is Claude Cowork?

• Cowork is Claude operating directly on your computer — reading, editing, and producing real files
• Works with documents, spreadsheets, images, PDFs, folders, and apps on your machine
• Available inside the Claude Desktop app (macOS and Windows)
• Not a browser extension or web-only tool — it integrates with your local filesystem
• Outputs are real: edited files are saved to disk, created files exist on your drive
• Think of it as Claude as a hands-on collaborator, not just a conversational assistant

How Cowork Differs from Other Modes

┌─────────────────────────────────────────────────────────────────┐
│                   Claude Modes Comparison                       │
│                                                                 │
│   CHAT MODE          COWORK MODE          CODE MODE            │
│  ┌──────────┐       ┌──────────┐        ┌──────────┐           │
│  │Text only │       │ Files +  │        │Terminal  │           │
│  │Q&A style │       │ Folders  │        │Commands  │           │
│  │No file   │       │Read/Write│        │Developer │           │
│  │access    │       │Documents │        │Focused   │           │
│  └──────────┘       └──────────┘        └──────────┘           │
│  "What is X?"       "Edit this doc"    "Run npm build"         │
│  Everyone           Everyone           Developers              │
└─────────────────────────────────────────────────────────────────┘

Getting Set Up

• Download the Claude Desktop app from claude.ai (macOS or Windows)
• Sign in with your Anthropic account (Claude Pro, Max, or Enterprise plan)
• Open the app and navigate to the Cowork tab in the sidebar
• Grant file access permissions when prompted — Cowork needs them to read/write your files
• No additional installation required; Cowork is built into the Desktop app

Running Your First Task

• Drag a file (document, spreadsheet, image, PDF) directly into the Cowork conversation
• Type a natural language instruction: “Summarize this”, “Edit this”, “Analyze this”
• Claude reads the file, performs the task, and returns the result
• For file edits: Claude shows the changes and saves them to your disk
• For analysis: Claude returns a structured summary or report in the conversation

What Cowork Can Work With

• Word documents (.docx), PDFs, text files (.txt, .md)
• Spreadsheets (.xlsx, .csv)
• Images (JPG, PNG — for analysis and description)
• Entire folders (drag a folder to work on multiple files at once)
• URLs (paste a link for Claude to read web content)
• Any combination of the above in one conversation

Best Practices

• Start simple — drag one file and ask one clear question before combining multiple files
• Be explicit — “Rewrite this in a professional tone” beats “make this better”
• Check outputs — Cowork edits real files; review changes before sharing them
• Use the right mode — Cowork for documents; Chat for knowledge questions; Code for software
• Grant necessary permissions — if Cowork can’t access a file, check app permissions in Settings
• Organize your workspace — keep files you want to work on in accessible folders

Example

Scenario: Cleaning up a meeting notes document

1. User drags meeting-notes-2026-04-26.docx into Cowork
2. Types: “Organize these notes into action items, decisions made, and open questions”
3. Cowork reads the document, identifies three categories of content, restructures it
4. Returns the reorganized document saved to the same location
5. User reviews, then drags the file to Cowork again: “Make the action items a numbered list sorted by owner”
6. Cowork edits the file again with the requested change

MODULE 2: The Task Loop

Key Notes

Understanding the Task Execution Process

The task loop is Cowork’s core execution model — how every task moves from request to result:

┌─────────────────────────────────────────────────────────────────┐
│                    THE TASK LOOP                                │
│                                                                 │
│   1. USER GIVES TASK                                            │
│      "Summarize the Q1 report and highlight risks"             │
│              │                                                  │
│              ▼                                                  │
│   2. CLAUDE READS CONTEXT                                       │
│      Reads Q1-report.pdf + any project-level instructions      │
│              │                                                  │
│              ▼                                                  │
│   3. CLAUDE REASONS                                             │
│      Plans the approach: what to extract, how to summarize     │
│              │                                                  │
│              ▼                                                  │
│   4. CLAUDE ACTS                                               │
│      Creates summary document, highlights risk sections        │
│              │                                                  │
│              ▼                                                  │
│   5. RESULTS SHOWN                                              │
│      Output displayed + file saved to disk                     │
│              │                                                  │
│              ▼                                                  │
│   6. USER REVIEWS & RESPONDS                                    │
│      "Good, but also add a comparison to Q4 last year"        │
│              │                                                  │
│              ▼                                                  │
│   7. LOOP CONTINUES ──────────────────────────────────────►    │
│      Claude acts again, incorporating feedback                  │
└─────────────────────────────────────────────────────────────────┘

Key Loop Properties

• Claude retains session context — it remembers what was done earlier in the conversation
• Each loop iteration builds on previous ones — no need to repeat context
• User controls when the loop ends — keep refining until satisfied
• Loop is conversational — natural language feedback drives each iteration
• Loop is file-aware — changes accumulate on disk across iterations

Giving Cowork Context

Context is how you help Claude understand what to work with and what you want:

Referencing Files by Name

• If a file was already dragged in, refer to it by name: “Now add a conclusion to the report we just edited”
• Claude tracks which files are in scope for the current session
• Reference multiple files together: “Compare the Q1 and Q2 reports”

Setting Project-Level Instructions

• Open Cowork Settings and add instructions like: “I’m a marketing manager. Use formal language.”
• Project instructions apply to every task in that project — no need to repeat them
• Examples: default output language, preferred document format, writing style, role context

Making Claude Cowork Yours

• Custom instructions — Tell Claude your role, preferences, and style once; it applies everywhere
  • “I’m a software engineer. Keep technical terms; don’t over-explain.”
  • “My audience is non-technical executives. Avoid jargon.”
  • “Always output in bullet point format, not paragraphs.”
• Session continuity — Claude remembers context within a session; use this to chain tasks
• Iterative refinement — Cowork is designed for back-and-forth; don’t try to get it perfect in one shot

Best Practices

• Front-load context — Drag all relevant files in at the start, not mid-task
• Be specific about output — “Create a new file called summary.md” vs “summarize this”
• Use project instructions — Set your role and preferences once; don’t repeat them every session
• Iterate freely — Cowork is designed for refinement; multiple loops produce better output than one complex prompt
• Name your files clearly — “Q1-revenue-report.xlsx” is easier to reference than “file1.xlsx”
• Check permissions early — If Cowork can’t access a folder, fix it before starting a complex task

Example

Scenario: Multi-step research synthesis

1. User drags three PDF research papers and a notes.txt into Cowork
2. Task: “Extract the key findings from each paper”
3. Cowork reads all four files, extracts findings per paper → shows results
4. User: “Now combine them into a single synthesis document organized by theme”
5. Cowork creates synthesis.md on disk with themed sections
6. User: “The ‘methodology’ section is weak — expand it using the third paper”
7. Cowork edits synthesis.md, expands the methodology section referencing paper 3
8. Loop ends when user is satisfied

MODULE 3: Making Claude Cowork Yours

Key Notes

Plugins: Cowork as a Specialist

Plugins transform Cowork from a general assistant into a domain specialist:

• A plugin is a pre-configured skill set that focuses Claude on a specific type of work
• Plugins bundle together: custom instructions, tool configurations, and behavioral defaults
• Activating a plugin changes how Cowork responds, what it prioritizes, and how it formats output
• Plugins can restrict or expand what Cowork does by default

┌────────────────────────────────────────────────────────────────┐
│                   Plugin Architecture                          │
│                                                                │
│   BASE COWORK                                                  │
│   ┌──────────────────────────────────────────────────────┐    │
│   │  General file/doc operations, natural language tasks  │    │
│   └──────────────────────────────────────────────────────┘    │
│                          +                                     │
│   PLUGIN (e.g., Data Analyst)                                  │
│   ┌──────────────────────────────────────────────────────┐    │
│   │  Custom instructions: "Focus on numeric insights"     │    │
│   │  Tool config: Prefer tabular output, charts           │    │
│   │  File rules: Prioritize .csv, .xlsx over .docx        │    │
│   └──────────────────────────────────────────────────────┘    │
│                          =                                     │
│   SPECIALIZED COWORK                                           │
│   ┌──────────────────────────────────────────────────────┐    │
│   │  Claude behaves like a Data Analyst specialist        │    │
│   └──────────────────────────────────────────────────────┘    │
└────────────────────────────────────────────────────────────────┘

Plugin Examples

Plugin Sources

• Built-in plugins — Provided by Anthropic in the Claude Desktop app
• Community plugins — Shared by other users via the plugin library
• Custom plugins — Created by your organization or yourself (Enterprise tier)
• Install from the plugin library in Cowork Settings → Plugins → Browse

Scheduled Tasks

Scheduled tasks enable Cowork to work in the background on a recurring basis:

• Define a task, specify input files/folders, set a schedule, and Cowork runs it automatically
• You don’t need to be in the app — tasks run in the background and results are saved when complete
• Check results when convenient: they’re saved to your specified output location

Scheduled Task Configuration

┌────────────────────────────────────────────────────────────────┐
│               Scheduled Task Setup                             │
│                                                                │
│   TASK:    "Summarize all new files in /inbox and save        │
│            summaries to /summaries"                           │
│                                                                │
│   SCHEDULE:  Daily at 8:00 AM                                 │
│                                                                │
│   INPUT:    Folder: ~/Documents/inbox/                        │
│             Files added since last run                        │
│                                                                │
│   OUTPUT:   Folder: ~/Documents/summaries/                    │
│             File per input: {filename}-summary.md             │
│                                                                │
│   STATUS:   Active — last ran 2026-04-26 08:00 AM            │
└────────────────────────────────────────────────────────────────┘

Scheduled Task Use Cases

• Daily report generation: “Every morning, summarize yesterday’s emails and save to daily-brief.md”
• Weekly data analysis: “Every Monday, analyze last week’s sales.csv and create a trends report”
• Periodic file organization: “Every Sunday, rename files in /downloads to follow our naming convention”
• Content monitoring: “Check this folder for new PDFs and extract key data to a master spreadsheet”
• Meeting prep: “Before each Monday meeting, compile notes from the past week into an agenda”

Plugin vs Scheduled Task vs Custom Instructions

Best Practices

• Match plugin to task type — Don’t use the Writing Assistant plugin for data analysis
• Read plugin documentation — Each plugin has specific strengths; understand them before relying on it
• Start tasks manually before scheduling — Run a task manually first to verify the output, then schedule it
• Set clear output locations — Scheduled tasks need a predictable output folder; name it clearly
• Review scheduled task outputs — Automation doesn’t replace review; check outputs periodically
• Combine plugins with custom instructions — Plugin sets domain context; instructions set personal preferences
• Disable plugins when not needed — Active plugins change Cowork’s behavior; deactivate to return to general mode

Example

Scenario: Setting up automated competitive research

1. User installs the “Research Analyst” plugin from the plugin library
2. Configures plugin with custom instruction: “Focus on product features and pricing comparisons”
3. Creates a scheduled task:
   • Input: folder of competitor press releases (added weekly)
   • Task: “Extract new product features and pricing changes, append to competitive-tracker.md”
   • Schedule: Every Friday at 5 PM
4. The scheduled task runs automatically each Friday
5. User reviews competitive-tracker.md on Monday mornings — already populated
6. Result: recurring competitive intelligence with zero manual effort per week

MODULE 4: Claude Cowork in Practice

Key Notes

File and Document Tasks

Cowork handles a wide range of document operations:

┌────────────────────────────────────────────────────────────────┐
│              Document Task Types                               │
│                                                                │
│   EDIT          CREATE          CONVERT          ANALYZE       │
│   ─────         ──────          ───────          ───────       │
│   Rewrite       Drafts          CSV→Table        Summarize     │
│   Reformat      Outlines        PDF→Text         Extract data  │
│   Proofread     Templates       DOCX→MD          Find patterns │
│   Translate     Reports         Images→Desc      Compare docs  │
│   Summarize     Presentations   Audio→Notes      Risk flags    │
└────────────────────────────────────────────────────────────────┘

Editing Documents

• “Rewrite this report in a more professional tone” — full document rewrite
• “Fix all grammar errors in this document” — targeted proofreading
• “Shorten this to under 500 words without losing key points” — condensing
• “Translate this to Spanish, keeping technical terms in English” — translation with rules
• “Make the introduction more compelling for an executive audience” — audience-specific editing

Creating New Files

• “Create a presentation outline based on these research notes” → outline.md
• “Write a project proposal template based on this example” → proposal-template.docx
• “Generate a weekly status report for this project folder” → status-report-2026-04-26.md
• Cowork saves the new file to your specified location (or asks where to save it)

Converting and Processing Formats

• “Convert this CSV to a formatted table” — raw data → readable format
• “Extract all the invoice totals from these PDFs into a spreadsheet” — PDF → Excel
• “Rename all files in this folder to follow kebab-case naming” — batch rename
• “Combine these four text files into one document with section headers” — merge operation

Image Analysis

• “Describe what’s in these screenshots” — visual content to text
• “Extract the text from this scanned document” — OCR-style extraction
• “Identify any charts or graphs in this PDF and summarize their data” — data extraction from visuals
• “Compare these two UI screenshots and list the differences” — visual diff

PDF Processing

• “Extract the key data points from this invoice” — structured extraction
• “Summarize the findings section of this research paper” — targeted reading
• “List all the action items from this meeting transcript PDF” — task extraction
• “Pull all dates and deadlines from this contract” — pattern extraction

Research and Analysis at Scale

Cowork’s real power emerges when working across multiple files simultaneously:

┌────────────────────────────────────────────────────────────────┐
│           Research at Scale: Multi-Source Workflow             │
│                                                                │
│   INPUT SOURCES                                                │
│   ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐             │
│   │ PDF 1  │  │ PDF 2  │  │CSV Data│  │Web URL │             │
│   └────┬───┘  └────┬───┘  └────┬───┘  └────┬───┘             │
│        │           │           │            │                  │
│        └───────────┴───────────┴────────────┘                 │
│                          │                                     │
│                          ▼                                     │
│              COWORK SYNTHESIZES                                │
│          Reads all sources, finds patterns,                    │
│          cross-references, resolves conflicts                  │
│                          │                                     │
│                          ▼                                     │
│   OUTPUT                                                       │
│   ┌──────────────────────────────────────────┐                │
│   │  synthesis-report.md                      │                │
│   │  - Key findings (all sources)             │                │
│   │  - Conflicting data flagged               │                │
│   │  - Themes across sources                  │                │
│   │  - Gaps identified                        │                │
│   └──────────────────────────────────────────┘                │
└────────────────────────────────────────────────────────────────┘

Multi-Source Research

• Drag multiple PDFs, articles, and documents into one conversation
• “Identify the common themes across all these research papers”
• “What does each source say about climate risk? Synthesize into one table”
• Cowork cross-references sources, resolves contradictions, identifies consensus

Data Analysis

• Drag a spreadsheet and ask: “Find the top 5 products by revenue this quarter”
• “Identify any anomalies in this sales data”
• “Create a summary of trends from this 12-month dataset”
• Cowork produces a narrative analysis, not just formulas

Competitive and Comparative Analysis

• “Compare these two product specs documents — what’s different?”
• “Which of these three vendor proposals offers the best value? Analyze each”
• Side-by-side comparison tables with narrative summary

Content Synthesis

• “Combine these five meeting notes into a single project status document”
• “Take these three expert interviews and write a synthesis report”
• Output is a coherent, unified document, not just concatenated content

Best Practices

• Batch similar operations — Drag multiple files at once for batch tasks (“rename all”, “summarize all”)
• Specify output location — Tell Cowork where to save created files; don’t rely on defaults
• Use specific language for extractions — “Extract the invoice total, vendor name, and due date” vs “get the info”
• Verify extracted data — For financial or legal documents, always review Cowork’s extractions manually
• Break large analyses into steps — “First extract, then analyze, then summarize” produces better results than one mega-prompt
• Use comparison tables — Ask Cowork to produce table output for comparisons; easier to scan than prose
• Save intermediate outputs — For long research tasks, ask Cowork to save intermediate files so you can resume

Example

Scenario: Quarterly business review preparation

1. User drags 8 files into Cowork: Q2 sales.xlsx, customer-feedback.csv, ops-report.pdf, 4 team update docs
2. Task: “Analyze all these files and identify the top 3 wins and top 3 challenges for Q2”
3. Cowork reads all 8 files, cross-references data → produces findings
4. User: “Now create a QBR slide deck outline based on these findings”
5. Cowork creates qbr-outline.md with slide-by-slide breakdown
6. User: “Expand the ‘Customer Success’ section — use the feedback CSV data as evidence”
7. Cowork edits qbr-outline.md with data-backed customer success content
8. Total time: 15 minutes vs. 3 hours of manual synthesis

MODULE 5: Working Responsibly

Key Notes

Permissions: How Cowork Accesses Your Files

Cowork is designed with explicit permission boundaries:

┌────────────────────────────────────────────────────────────────┐
│                  Permission Model                              │
│                                                                │
│   LEVEL 1: App Permissions (macOS/Windows)                    │
│   Claude Desktop asks for folder access at the OS level       │
│   You approve which folders are accessible                     │
│                                                                │
│   LEVEL 2: Cowork Settings                                     │
│   Within accessible folders, you can further restrict          │
│   what Cowork reads/writes by default                         │
│                                                                │
│   LEVEL 3: Task-Level Approval                                 │
│   For sensitive files or write operations, Cowork             │
│   asks "May I edit this file?" before proceeding              │
│                                                                │
│   LEVEL 4: Review Before Save                                  │
│   Cowork shows proposed changes before finalizing             │
│   User approves or rejects                                    │
└────────────────────────────────────────────────────────────────┘

Permission Principles

• Cowork asks before writing — it won’t silently overwrite files without showing you the change
• Cowork respects folder boundaries — it only accesses folders you’ve explicitly granted
• Sensitive files (passwords, private keys, financial records) require explicit approval per task
• No data leaves your computer without permission — file content is processed locally or sent to Claude’s API only for the active task
• You can revoke access at any time in macOS System Settings → Privacy → Files and Folders

Usage and Model Selection

Cowork supports multiple Claude models optimized for different needs:

Choosing the Right Model

• Haiku for: rename files, fix grammar, convert formats, simple summaries
• Sonnet for: most work — analysis, research, multi-file tasks, content creation
• Opus for: complex legal review, nuanced writing requiring deep reasoning, critical analysis

Token Usage and Plans

┌────────────────────────────────────────────────────────────────┐
│                  Plan Comparison                               │
│                                                                │
│   CLAUDE FREE                                                  │
│   - Limited Cowork usage per month                            │
│   - Haiku and Sonnet only                                     │
│   - Basic file access                                         │
│                                                                │
│   CLAUDE PRO                                                   │
│   - Higher Cowork usage limits                                │
│   - All models including Opus                                 │
│   - Scheduled tasks (basic)                                   │
│                                                                │
│   CLAUDE MAX                                                   │
│   - Highest usage limits                                      │
│   - Priority access                                           │
│   - Full scheduled task support                               │
│   - Plugin library access                                     │
│                                                                │
│   CLAUDE ENTERPRISE                                            │
│   - Unlimited usage                                           │
│   - Custom plugins                                            │
│   - SSO and admin controls                                    │
│   - Data residency options                                    │
└────────────────────────────────────────────────────────────────┘

Token Efficiency Tips

• Large files use more tokens — for very large documents, specify the section you want analyzed
• Batch similar tasks in one session (cheaper than separate sessions for same files)
• Use Haiku for simple tasks to conserve usage for complex tasks where Sonnet/Opus is needed
• Summarize large files first, then work from the summary for follow-up analysis

Troubleshooting Common Issues

Troubleshooting Strategy

1. Start with permissions — most “can’t read file” errors are permission issues
2. Simplify the task — if Cowork fails a complex task, break it into smaller steps
3. Add more context — wrong results usually mean insufficient context; add more files or instructions
4. Check the output location — if you can’t find a created file, ask: “Where did you save it?”
5. Use absolute paths — “Save to /Users/me/Documents/reports/” is clearer than “save to my reports folder”

Responsible Use Guidelines

• Review all edits before sharing — Cowork may make mistakes; always review outputs
• Verify extracted data — Cross-check important numbers or dates with source documents
• Don’t rely on Cowork for legal or medical advice — it processes documents, it doesn’t give professional advice
• Be mindful of sensitive content — Don’t drag confidential files into Cowork unless you understand how data is handled
• Understand your organization’s policy — Some organizations have restrictions on AI tools; check before using Cowork with work files

Best Practices

• Review before acting — For critical documents, always read Cowork’s changes before saving or sharing
• Use the right model for the job — Don’t use Opus for simple tasks; don’t use Haiku for nuanced analysis
• Manage your token budget — Monitor usage in the Claude Desktop app Settings → Usage
• Keep a backup before large edits — Duplicate important files before asking Cowork to make major changes
• Report incorrect outputs — Use the feedback button to flag wrong results; it improves the model
• Don’t share proprietary data unnecessarily — Only include files Cowork actually needs for the task
• Use project settings for repeated work — Set context once per project, not per conversation

Example

Scenario: Reviewing a vendor contract responsibly

1. User confirms their organization allows AI tools for contract review (policy check first)
2. Duplicates vendor-contract.pdf to vendor-contract-backup.pdf before starting
3. Drags vendor-contract.pdf into Cowork with the Legal Reviewer plugin active
4. Task: “Identify all clauses related to liability limitations, payment terms, and termination”
5. Selects Opus model (complex legal reasoning)
6. Cowork extracts and summarizes the three clause types
7. User reviews the extraction against the original PDF — cross-checks three key clauses manually
8. Task: “Flag any clauses that seem unusual or potentially unfavorable”
9. Cowork highlights two clauses with explanations
10. User shares the analysis with their legal team for professional review before signing

MODULE 6: Assessment

Key Notes

Quiz Preparation: Core Concepts

This module tests your understanding of all previous modules. Focus on:

Module 1 — Core distinctions

• Cowork vs Chat vs Code mode: what each does, who it’s for, file access differences
• Setup requirements: Claude Desktop app (not web), sign-in, navigate to Cowork tab
• First task mechanics: drag file → natural language instruction → real output on disk

Module 2 — Task loop literacy

• All 7 steps of the task loop (User gives task → Read context → Reason → Act → Show results → User reviews → Loop continues)
• Ways to provide context: drag files, drag folders, paste URLs, upload images, set project instructions
• Session continuity: Claude remembers within a session; no need to re-explain context mid-loop

Module 3 — Plugins and scheduling

• What a plugin is: pre-configured skill set with custom instructions + tool config
• Plugin sources: built-in, community library, custom (Enterprise)
• Scheduled tasks: automatic background execution, output saved to disk, requires app to be running

Module 4 — Practical applications

• Document task types: edit, create, convert, analyze — know examples of each
• Research at scale: multi-source synthesis, cross-referencing, finding patterns across files
• Batch operations: Cowork can rename, process, or analyze multiple files in one task

Module 5 — Responsible use

• Permission model: 4 levels (OS, Settings, task approval, review before save)
• Model selection: Haiku (fast/simple), Sonnet (balanced/most tasks), Opus (complex/critical)
• Key troubleshooting: permissions → simplify → add context → verify paths

Common Quiz Traps

Best Practices

• Review all six modules before taking the assessment — questions span all modules equally
• Know the task loop steps in order — this is a foundational concept with specific sequence
• Practice distinguishing modes — Chat/Cowork/Code differences appear frequently
• Understand permission levels — the 4-level permission model is commonly tested
• Know model trade-offs — when to use each model is tested through scenario-based questions

Example

Sample Quiz Questions

Q1: A colleague wants to use Cowork to ask Claude questions about Python programming. What should you tell them?

• A: Cowork is the right tool for this
• B: They should use Chat mode for Q&A; Cowork is for file-based work
• C: They need the Enterprise plan to use Cowork for programming
• D: Cowork can’t help with programming questions at all
• Correct Answer: B — Chat is for conversational Q&A; Cowork is for file/document operations

Q2: A user reports their scheduled task didn’t run overnight. What is the most likely cause?

• A: The task instructions were too complex
• B: The Claude Desktop app was not running
• C: The user needs a higher plan tier
• D: Scheduled tasks don’t support overnight runs
• Correct Answer: B — Scheduled tasks require Claude Desktop to be open and running

Q3: Which model would you recommend for reviewing a complex 80-page legal contract for risk clauses?

• A: Haiku — fastest processing for large documents
• B: Sonnet — balanced; handles most document tasks
• C: Opus — most powerful; best for complex reasoning and nuanced analysis
• D: Any model — legal documents are processed the same way regardless
• Correct Answer: C — Complex legal reasoning requires Opus’s deeper analytical capability

Final Summary and Certification Checklist

Core Concepts at a Glance

┌────────────────────────────────────────────────────────────────┐
│              Claude Cowork — Knowledge Map                     │
│                                                                │
│   WHAT IT IS                                                   │
│   Claude operating on your actual files and folders           │
│   Available in Claude Desktop app (macOS/Windows)             │
│                                                                │
│   HOW IT WORKS                                                 │
│   Task Loop: Give task → Read → Reason → Act → Show → Loop   │
│                                                                │
│   HOW TO CUSTOMIZE                                             │
│   Custom instructions + Plugins + Scheduled tasks             │
│                                                                │
│   WHAT YOU CAN DO                                              │
│   Edit, create, convert, analyze, batch, research at scale    │
│                                                                │
│   HOW TO USE RESPONSIBLY                                       │
│   Permissions + right model + review outputs + backups        │
└────────────────────────────────────────────────────────────────┘

Certification Readiness Checklist

Module 1 — Meet Claude Cowork

• Can explain what Cowork is and how it differs from Chat and Code modes
• Know the setup steps: Desktop app → sign in → Cowork tab → grant permissions
• Understand what file types Cowork can work with
• Know how to run a first task (drag file → natural language instruction)

Module 2 — The Task Loop

• Can list all 7 steps of the task loop in order
• Know all ways to provide context (files, folders, URLs, images, project settings)
• Understand session continuity and how Claude remembers context
• Know how to make Cowork yours with custom instructions and project settings

Module 3 — Plugins and Scheduled Tasks

• Can define what a plugin is and what it contains
• Know plugin sources: built-in, community library, custom (Enterprise)
• Understand scheduled task configuration (task, schedule, input, output)
• Know the limitation: scheduled tasks require the app to be running

Module 4 — Cowork in Practice

• Can give examples of edit, create, convert, and analyze tasks
• Understand batch operations (rename all, summarize all, analyze all)
• Know how multi-source research works (multiple files in one conversation)
• Understand content synthesis (combining multiple sources into one output)

Module 5 — Working Responsibly

• Know the 4 levels of the permission model
• Can match model to task: Haiku/Sonnet/Opus and when to use each
• Know troubleshooting sequence: permissions → simplify → context → paths
• Understand responsible use: review outputs, verify data, no professional advice

Module 6 — Assessment Ready

• Reviewed all module key notes above
• Practiced distinguishing Chat vs Cowork vs Code mode
• Memorized the task loop steps in order
• Understand common quiz traps (browser availability, model selection, scheduled task requirements)

Study tip: The most commonly tested concepts are the mode comparisons (Chat/Cowork/Code), the task loop steps in sequence, and the permission model levels. Review the comparison tables and the troubleshooting table in Module 5 before the assessment.