4.11 Cowork - Autonomous File Access

Course: Claude Code - Essentials Section: Claude Desktop App Video Length: 2-5 minutes Presenter: Daniel Treasure

Opening Hook

Claude Code is for developers. But what if you need Claude to help with file organization, document generation, data cleanup, or other knowledge work? That's Cowork—Claude's autonomous file access mode. It's Claude as your AI coworker, not just your AI pair programmer.

Key Talking Points

1. What is Cowork? (The New Capability)

Cowork is Claude operating in your files without being explicitly tied to coding tasks
You grant Claude access to a specific folder, and it works autonomously on file-based tasks
Runs in an isolated, sandboxed environment on your machine (for security)
Available in the Claude desktop app as a dedicated mode
Launched in January 2026 as a research preview; now available to Pro, Team, and Enterprise

What to say: "Cowork is Claude Code's non-technical cousin. Instead of coding, Claude can organize files, generate reports, clean up documents, process spreadsheets, or any file-based task that requires agentic work."

What to show on screen: Show the Cowork mode toggle or launch button in the desktop app. Show a folder being selected for Cowork access. Display a simple Cowork task in progress.

2. Use Cases: Beyond Code

Give concrete, relatable examples of what Cowork is good for: - File organization: Rename, categorize, and organize scattered files across folders - Document generation: Read source files, generate summaries, reports, or marketing materials - Data cleanup: Parse CSVs, detect duplicates, standardize formats - Bulk operations: Rename batch files, convert formats, remove unused assets - Documentation: Extract information from code and auto-generate user guides - Content creation: Batch-process files, generate variations, or extract metadata

What to say: "Say you have 500 product images without proper naming. Ask Cowork to organize them. Or you have a folder of scattered research notes—ask Cowork to synthesize them into a report. It's productive work that doesn't require code."

What to show on screen: Show one use case in action (file organization, document generation, or data cleanup). Show the before and after—folder state before Cowork, then after Cowork completes the task.

3. Permission Model: Folder Grant (The Safety Mechanism)

Explain how Cowork differs from regular Claude Code: - You explicitly select a folder (or multiple folders) and grant Cowork access - Cowork can only see and modify files within that folder - All access is visible in the UI; no hidden operations - You can revoke folder access at any time - This is safer than full system access because it's scoped

What to say: "You don't have to worry about Cowork modifying files it shouldn't touch. You choose the exact folder, and Cowork stays in that boundary. If you change your mind, revoke access instantly."

What to show on screen: Show the folder selection dialog in Cowork. Highlight that it's a permission grant—like giving an app access to your Photos folder on iOS. Show the "Active folder access" indicator in the Cowork UI.

4. Autonomous Planning & Execution (The Workflow)

Explain how Cowork thinks and acts: - You describe a goal (e.g., "organize these files by type") - Cowork creates a plan showing the steps it will take - You review the plan before execution (transparency) - Cowork executes the plan, working through files autonomously - You can pause, adjust, or cancel at any time

What to say: "Cowork doesn't ask permission for every single file. You approve the plan upfront, and Cowork executes efficiently. If you want to adjust the approach, you can interrupt and redirect."

What to show on screen: Show a Cowork task with a visible plan (bullet points of what it will do), then show the execution phase where Cowork works through files.

5. Practical Examples (The "How-To" Intuition)

Give examples of how to phrase requests to Cowork: - "Organize my Downloads folder: group files by type (images, documents, videos, archives)" - "Generate a README from the comments in all Python files in this folder" - "Find duplicate images and move duplicates to a 'duplicates' subfolder" - "Extract metadata from PDFs and create a CSV summary" - "Rename all files in this folder to follow pattern YYYY-MM-DD_name"

What to say: "Cowork understands English requests. Be clear about what folder you're working with, what the end goal is, and any rules or constraints. Then let it work."

What to show on screen: Show one or two example prompts in the Cowork UI. Show Claude processing and completing the task.

6. When NOT to Use Cowork (The Boundaries)

Set expectations about limitations: - Cowork is not for coding tasks (use Claude Code for that) - Not for tasks requiring external APIs or system commands (unless pre-approved) - Not for real-time or time-sensitive work (it runs asynchronously) - Not for modifying system files or operating system directories (safety boundary)

What to say: "Cowork is great for file-based knowledge work. But if you're building software, testing code, or doing something that touches system configs, stick with Claude Code. They're complementary, not interchangeable."

What to show on screen: Just text or a simple visual showing what Cowork is and isn't suitable for.

Demo Plan

This is a showcase demo showing Cowork's capability and ease of use.

Open the desktop app and switch to Cowork mode (if visible, show the mode toggle)
Grant folder access by selecting a sample folder (e.g., Documents, Downloads, or a project folder)
Describe a file-based task (e.g., "organize these files by type" or "generate a summary of all notes")
Show Cowork's plan (the steps it intends to take)
Approve the plan and show Cowork executing
Show the progress (files being moved, renamed, or processed)
Show the result (folder state after Cowork completes)
Highlight that folder access can be revoked anytime

This should take 2-3 minutes and demonstrate: - Cowork is accessible and easy to use - Plans are transparent before execution - Results are immediate and visible - The safety model (scoped folder access) is clear

Code Examples & Commands

No code for Cowork—it's entirely conversational UI.

Example Cowork requests (for reference, not shown):

"Organize these files: group by type (images, documents, videos, code)"
"Generate a report from all markdown files in this folder"
"Find and list all duplicate files by file hash"
"Rename all PDFs to YYYY-MM-DD_description format"
"Extract table of contents from all markdown files and create index.md"

Gotchas & Tips

Folder access is explicit: Cowork will only touch the folder you grant access to. Subfolders are included
Plans are reviewable: Always look at the plan before approving. If it doesn't match your intent, reject and clarify
Execution is asynchronous: Cowork may take time for large tasks. You don't need to stay in the app
File permissions matter: If your OS restricts write access to a folder, Cowork can't modify files there (grants need to sync with OS permissions)
Undo is manual: Cowork doesn't have an undo button. Review results and manually undo if needed (or ask Cowork to redo it differently)
Cowork is separate from Claude Code: They share account context but are different modes. Settings for one don't necessarily apply to the other

Lead-out

"Cowork expands Claude's power beyond coding. You've now seen the full range: Claude Code for software development, and Cowork for knowledge work. You're ready to use these tools in your real workflow. In the next section, we'll cover troubleshooting and common gotchas—because eventually you'll hit a snag, and we'll show you how to solve it."

Reference URLs

Prep Reading

Anthropic's official Cowork announcement blog post (January 12, 2026)
TechCrunch coverage: "Anthropic's new Cowork tool offers Claude Code without the code"
Simon Willison's deep dive on Cowork capabilities
VentureBeat coverage on Cowork for non-technical knowledge workers
Real-world use cases from recent articles and community posts

Notes for Daniel: This is the "wow" moment of Section 4. Cowork feels like magic—you point Claude at a folder and things happen. Show the ease and transparency. Emphasize that this is new and expanding Claude beyond developers. The energy should be enthusiastic but grounded—this is a real tool with real limitations, not hype. This video also sets up the transition to Section 5 (Troubleshooting) nicely: you've shown the power, now we'll show how to handle when things don't go as planned.

Quick Reference