Chapter 3: Using Claude Desktop and Cowork
The chapter introduction explains why moving from Claude on the web to a permissioned local workspace reduces file transfers and supports Git-backed work.
After this chapter you will be able to
- Web Interface File Boundary. Explain why continuing the project in Claude on the web would require repeated uploads and downloads.
- Cowork Local Tool Access. Describe how Claude Desktop and Cowork change where tools work while distinguishing those tools from the model.
- Attachment workflow limitations. Explain why uploading and downloading file attachments works for a quick question but creates friction and versioning problems for a long-running project.
- Cloud model and local sandbox. Describe where Claude reasons in a Cowork session and what its restricted local sandbox does with permitted folders, inputs, and outputs.
- Chats versus Cowork tasks. Distinguish Desktop’s regular chats from Cowork tasks, including their access to local content and where their histories are available.
- Scoped folder access. Explain what granting Cowork access to a folder permits, why the section recommends choosing a specific folder, and how access is limited to a task.
- Local sandbox tool flow. Trace how the model uses Cowork’s local sandbox to run a command, receive its output, and write a file.
- Local dataset research setup. Describe how to start a Cowork research task with downloaded datasets and steer Claude toward an analysis.
- Local analysis and context. Trace how Claude analyzed the ZIP files and explain why the raw CSV data did not fill its context.
- Two kinds of projects. Distinguish chat projects, which group chats and shared inputs, from Cowork Projects, which group tasks around folders on your machine.
- Git diffs as review. Explain how keeping a Cowork Project's folders in Git lets you review Claude's changes as diffs, choose what to commit or push, and revert unwanted changes.
- MCP connector capabilities. Explain that an MCP server sits between Claude and an external system, exposes actions Claude can discover, and supports both reading data and making changes.
- Connector identity and permissions. Describe how service sign-in gives the connector access under your identity, and distinguish connector authorization from approval of individual actions. Explain why broad or long-term approval calls for care.
- Cowork connector request flow. Trace an email search from the model's tool request through Cowork and the MCP server to the returned results and saved summary.
- Connector-backed artifact operation. Trace what happens when a Cowork live artifact opens: Claude Desktop hosts its local HTML and JavaScript, fetches current data through MCP connectors, and supplies that data to the page. Explain that its scripts can also prompt Claude and that loading time is a practical limitation.
- Email dashboard creation and approval. Describe how to start a Cowork artifact, request an email-traffic dashboard, and approve its access to Gmail. Explain that Claude’s choice of email classification can affect the resulting chart, and that updates prompt for approval again.
- Screen-based app control. Explain how computer use lets Claude operate a desktop app and why it may help with apps that lack another integration point.
- Computer use safety limits. Explain the approval and privacy risks of computer use and the precautions the section recommends.
- Versioned design project setup. Describe how to prepare the application project with design documents in Git, including how to handle a design change before implementation.
What it builds on
- Structured and unstructured data (chapter 2) · Working with structured and unstructured data.
- Tokens and context windows (chapter 1) · The meaning of a context window.
- Claude’s knowledge and limits (chapter 2) · Claude’s knowledge and limits.
- Your turn: produce the component designs for your app (chapter 2) · The component designs produced for the application.
Section by section
Introduction
The chapter introduction explains why moving from Claude on the web to a permissioned local workspace reduces file transfers and supports Git-backed work.
- Web Interface File Boundary: Explain why continuing the project in Claude on the web would require repeated uploads and downloads.
Why it matters: This explains the practical problem the desktop workflow is meant to solve. - Cowork Local Tool Access: Describe how Claude Desktop and Cowork change where tools work while distinguishing those tools from the model.
Why it matters: The key change is local, permissioned tool access—not moving the model itself onto your computer. - Git Backed Working Folder: Explain the benefit of giving Claude read and write access to a folder that is a Git repository.
Why it matters: The working folder can serve as a controlled, shareable record of the project’s files.
Key terms: web interface, network boundary, upload-download round trips, Claude Desktop, Cowork, working sandbox, permissioned access, Git repository, version control, project files
3.1 Why you need the desktop app
This section explains why Cowork is useful for work involving local files, how it combines cloud-based reasoning with a local sandbox, and how its tasks differ from regular chats.
- Attachment workflow limitations: Explain why uploading and downloading file attachments works for a quick question but creates friction and versioning problems for a long-running project.
Why it matters: It explains why a project built around evolving documents benefits from something other than attachments. - Cloud model and local sandbox: Describe where Claude reasons in a Cowork session and what its restricted local sandbox does with permitted folders, inputs, and outputs.
Why it matters: It clarifies both what Cowork can do with local files and where Claude’s reasoning takes place. - Chats versus Cowork tasks: Distinguish Desktop’s regular chats from Cowork tasks, including their access to local content and where their histories are available.
Why it matters: It helps you choose between a synced quick conversation and a task involving local content.
Key terms: attachments, canonical source document, versioning problem, Claude Desktop, Cowork, sandbox, server-side, chat interface, task interface, Cowork task
3.2 Installing Claude Desktop and trying Cowork
This section gets readers started with Claude Desktop and Cowork, then uses a local-file task to explain permissions and how Cowork runs commands on the reader’s machine.
- Desktop setup and Cowork trial: Describe how to start using Claude Desktop with an existing account and try Cowork by asking it to count files in a folder, then create a summary file there.
Why it matters: The read-then-write trial makes Cowork’s local-file capabilities concrete. - Scoped folder access: Explain what granting Cowork access to a folder permits, why the section recommends choosing a specific folder, and how access is limited to a task.
Why it matters: Choosing a narrow folder lets Cowork do useful work without exposing more files than the task needs. - Local sandbox tool flow: Trace how the model uses Cowork’s local sandbox to run a command, receive its output, and write a file.
Why it matters: This distinction explains how a cloud model can work with local files and how you can inspect what it ran. - Local files as task context: Explain why connecting Cowork to local files is useful beyond answering a simple file-count question.
Why it matters: The file-count exercise is a starting point; local research is what makes the connection valuable for larger tasks.
Key terms: Claude Desktop, Cowork, summary.md, folder access, approved folder list, sandbox, task, model, command tool, local sandbox
3.3 Working with local files and folders
This section uses an OWID research task to show how Cowork works with a local folder, analyzes data without filling Claude’s context, and saves the resulting files.
- Local dataset research setup: Describe how to start a Cowork research task with downloaded datasets and steer Claude toward an analysis.
Why it matters: The folder and research question give Claude both the data and a useful direction for the task. - Local analysis and context: Trace how Claude analyzed the ZIP files and explain why the raw CSV data did not fill its context.
Why it matters: This distinction explains how Claude can reason about a dataset without putting all its rows into the conversation. - Limits of recalled data: Explain why additional research data should be fetched rather than reconstructed from Claude’s training data.
Why it matters: A plausible-sounding recalled figure is not a dependable replacement for a fetched dataset. - Task folder outputs: Distinguish the files left in the task’s folder from the intermediate analysis scripts.
Why it matters: Knowing what persists helps you find the deliverables and request reusable code when you need it.
Key terms: Cowork task, owid folder, ZIP files, sandbox, pandas, CSV files, context, summaries, training data, additional data sources
3.4 Projects: Organizing chats, tasks, and data
This section contrasts chat projects with Cowork Projects and explains how local folders and Git make Cowork work easier to organize, review, and reverse.
- Two kinds of projects: Distinguish chat projects, which group chats and shared inputs, from Cowork Projects, which group tasks around folders on your machine.
Why it matters: The project type determines whether Claude works with uploaded chat inputs or folders on your computer. - Chat project input limits: Explain how chat projects share instructions and uploaded files without syncing local files, and why brief instructions help conserve context and usage.
Why it matters: This helps you avoid treating a convenient shared chat workspace as a live connection to your files. - Cowork local folder access: Describe how a Cowork Project gives its tasks access to multiple local folders and why that both ties the project to one machine and removes manual file transfers.
Why it matters: Local folder links change how you keep a project's inputs and outputs available to Claude. - Git diffs as review: Explain how keeping a Cowork Project's folders in Git lets you review Claude's changes as diffs, choose what to commit or push, and revert unwanted changes.
Why it matters: A focused diff makes it more practical to delegate substantial changes without giving up control of the result.
Key terms: projects, chat projects, Cowork Projects, tasks, project-level instructions, chat context, sandbox, data courier, Cowork Project, folders
3.5 Accessing external systems with connectors
This section explains how connectors let Claude work with external systems through MCP, and uses an email task to show the execution flow and permission controls.
- MCP connector capabilities: Explain that an MCP server sits between Claude and an external system, exposes actions Claude can discover, and supports both reading data and making changes.
Why it matters: It explains how one approach lets Claude work with many external services. - Connector identity and permissions: Describe how service sign-in gives the connector access under your identity, and distinguish connector authorization from approval of individual actions. Explain why broad or long-term approval calls for care.
Why it matters: A connector's permissions determine what Claude can do in a real system under your identity. - Cowork connector request flow: Trace an email search from the model's tool request through Cowork and the MCP server to the returned results and saved summary.
Why it matters: The flow separates what the model decides to request from what the tools actually execute. - Email connector task: Describe how to connect an email service in Claude Desktop and use a Cowork task to summarize recent mail in a local file, then request a draft reply.
Why it matters: The example shows how external email data and a local deliverable can come together in one task.
Key terms: Model Context Protocol (MCP), MCP server, connectors, discoverable actions, OAuth token, action-by-action control, approve once, approve for this task, tool request, Cowork
3.6 Live artifacts and connectors
This section explains how Cowork live artifacts use connectors to refresh mini-apps with current data, using an email dashboard as an example.
- Cloud and Cowork artifacts: Distinguish live artifacts on claude.ai from those in Cowork by where they run, whether they can access MCP, and when Cowork artifacts refresh.
Why it matters: The distinction explains why the section uses Cowork for a connector-backed dashboard. - Connector-backed artifact operation: Trace what happens when a Cowork live artifact opens: Claude Desktop hosts its local HTML and JavaScript, fetches current data through MCP connectors, and supplies that data to the page. Explain that its scripts can also prompt Claude and that loading time is a practical limitation.
Why it matters: This explains both why a dashboard shows fresh information and why a more involved artifact might take time to open. - Email dashboard creation and approval: Describe how to start a Cowork artifact, request an email-traffic dashboard, and approve its access to Gmail. Explain that Claude’s choice of email classification can affect the resulting chart, and that updates prompt for approval again.
Why it matters: The example shows what creating and authorizing a connector-backed artifact looks like, including why its output may need revision.
Key terms: live artifacts, claude.ai, Cowork, MCP, live artifact, HTML, JavaScript, webview, connectors, Artifacts
3.7 Computer use: Letting Claude drive your desktop
This section explains how Claude Desktop can operate other apps through computer use, demonstrates it with Calculator, and warns about the permissions and risks involved.
- Screen-based app control: Explain how computer use lets Claude operate a desktop app and why it may help with apps that lack another integration point.
Why it matters: Computer use offers a way to work with an app even when Claude has no direct integration with it. - Computer use setup and example: Describe how to enable computer use and what Claude did in the Calculator example.
Why it matters: The Calculator example shows what granting access and letting Claude operate an app looks like in practice. - Computer use safety limits: Explain the approval and privacy risks of computer use and the precautions the section recommends.
Why it matters: An app-level approval can permit consequential actions while the captured screen may reveal information you did not mean to share.
Key terms: Computer use, context, legacy apps, Desktop settings, OS permissions, calculator app, approval, stop button, backup
3.8 Your turn: Set up your application project
This section has the reader prepare a shared Claude Code and Cowork workspace with version-controlled design documents ready for implementation.
- Shared codebase workspace: Explain why the reader creates a Cowork Project over the same folder that Claude Code will use.
Why it matters: The shared folder lets you use Desktop tools alongside your later coding work. - Versioned design project setup: Describe how to prepare the application project with design documents in Git, including how to handle a design change before implementation.
Why it matters: Committing the original and revised designs gives you an implementation-ready project and a record of what changed.
Key terms: Cowork Project, Claude Desktop tools, codebase, Git repo, design documents, docs/design, initial commit, commit history
3.9 Summary
Where this is used later
- Try it now — produce a stakeholder project pack (chapter 4) · Organizing project chats and data in Cowork
- Your role as reviewer (chapter 5) · Reviewing Claude's work depends on inspecting changes and deciding what to keep.
- Try it now — install my plugin and create a GitHub issue (chapter 4) · Provides the connector concept used when creating a GitHub issue through a plugin.
- Scheduled tasks: Recurring and on-demand automation (chapter 4) · Connecting Claude to an external system provides context for the Slack example.
- Your first Claude Code session (chapter 5) · The application codebase prepared here becomes the starting point for work with Claude Code.
Concepts explained in this chapter
- CoworkCowork is a Claude Desktop feature that provides a permissioned sandbox for running tools with access to local files and network services.
- sandboxingA sandbox environment is an isolated execution environment that restricts code and tool access from the surrounding system.
- permissions modelA permission model is a set of rules governing which actions and resource accesses are allowed, require approval, or are blocked.
- connectorA connector is Claude's integration for authenticating to and performing permitted operations on an external service.
- Git repositoryA Git repository is a directory and version-control database that stores files, commits, and their change history.
- MCPThe Model Context Protocol is an open standard for connecting AI models to external systems through discoverable, permissioned operations.
- MCP serverAn MCP server is lightweight middleware that exposes an external system's operations and data to an AI client through the Model Context Protocol.
- action-by-action controlAction-by-action control is a permission technique that lets a user allow, review, or block each external operation individually.
- authorizationAuthorization is the process of granting or restricting a verified user or client permission to perform specified operations.
- cowork projectA Cowork Project is a Claude Desktop project configuration that gives Claude access to a selected local folder and its contents.
- CSVCSV is a tabular text format that represents records as rows with fields separated by delimiters.
- SciPySciPy is a Python library providing numerical, scientific, and statistical computing functionality.
- correlationCorrelation is a statistical association describing how two variables vary together.
- data analysisData analysis is the systematic examination, transformation, and interpretation of data to identify patterns or answer questions.
- pandaspandas is a Python library for data manipulation and analysis using labeled tabular structures.
- structured dataStructured data is information organized according to a defined schema that makes its fields and records machine-readable.
- unstructured textUnstructured text is textual information without a fixed tabular or schema-constrained organization.
- live artifactA live artifact is a Claude-generated mini-application that runs in a cloud or local environment and refreshes data when opened.
- command toolThe command tool is a Cowork capability that executes model-generated shell commands inside the local sandbox.
- file write toolThe file write tool is a Cowork capability that writes model-generated content to an approved location on disk.
- diffA diff is a representation of the additions, deletions, and modifications between two versions of content.
- versioningVersioning is the practice of preserving and comparing successive states of files or other content.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
