Claude for Mac ships with three distinct modes — Chat, Cowork, and Code — each designed for a different kind of work. They share the same Claude brain but differ significantly in environment access, tooling, storage, and configuration. Choosing the right mode for the task at hand is the difference between fighting the tool and flowing with it.
The Three Modes at a Glance
| Chat | Cowork | Code | |
|---|---|---|---|
| Purpose | Quick exchanges | Complex, sustained work | Software engineering |
| File access | Via connectors only | Shared folders you choose | Full filesystem |
| Runs in | Desktop overlay | Isolated VM sandbox | Your project directory |
| MCP support | Connectors (GUI) | Connectors + manual MCP | Full MCP (GUI + config files) |
| Automation | Manual per query | Scheduled recurring tasks | Session-based, scriptable |
| Platform | macOS, Windows | Apple Silicon Mac, Windows | macOS, Windows, Linux (CLI) |
Chat Mode
Chat is the lightweight conversational interface. Double-tap Option on Mac and Claude appears as an overlay on top of whatever you’re working on. It’s the same Claude you know from the web, plus native desktop features:
- Screenshots and window sharing — grab what’s on your screen and drop it into the conversation
- Voice dictation — speak instead of type
- Connectors — plug in Google Calendar, Slack, GitHub, and other services through a graphical setup flow
- Quick entry — the overlay stays on top, so you can reference what’s behind it while talking to Claude
Chat has no direct file system access. It can’t read your project files or write code to disk. It works through connectors (which are MCP servers with a GUI wrapper) and whatever you paste into the conversation.
Best for: brainstorming, quick questions, drafting text, learning through dialogue, anything where you don’t need Claude touching your files.
Cowork Mode
Cowork is where Claude becomes an autonomous worker. Give it a folder, describe the task, and walk away. It reads your files, breaks the work into subtasks, runs them in parallel, and produces polished deliverables — spreadsheets with formulas, presentations, formatted documents.
Under the hood, Cowork runs the same engine as Code mode (Claude Code), but inside an isolated virtual machine on your computer. This sandbox means Claude can execute code safely without risking your system, while still making real changes to the files you’ve shared.
Key capabilities:
- Folder-scoped access — you choose which folders Claude can see. It reads what’s there, figures out what’s relevant, and saves outputs back to those folders
- Scheduled tasks — set up recurring work like daily briefings or weekly report generation that fires automatically
- Browser integration — Claude in Chrome lets Cowork navigate the web, fill forms, and pull data from websites
- Extended execution — tasks run for as long as needed without conversation timeouts
- Professional outputs — Excel files with working formulas, PowerPoint decks, formatted Word documents
Storage: Conversation history stays local on your device. Cowork activity is not captured in Audit Logs, Compliance API, or Data Exports.
Limitation: Requires Apple Silicon (M1 or later) on macOS. Intel Macs can use Chat and Code but not Cowork.
Best for: research briefs, financial analysis, contract review, document compilation, recurring administrative work — anything that requires sustained effort and polished output but doesn’t need full developer tooling.
Code Mode
Code mode is the full software engineering environment. It runs directly in your project with unrestricted access to your filesystem, terminal, and development tools. This is Claude Code — the same engine available as a CLI — wrapped in a desktop GUI with visual diff review, live app preview, and session management.
What sets Code apart:
- Full filesystem access — reads and writes anywhere in your project (and beyond, with permissions)
- Integrated terminal — runs commands, installs packages, executes tests
- Git integration — commits, branches, creates PRs, monitors CI checks with auto-fix and auto-merge
- Visual diff review — see every change file by file, leave inline comments, ask Claude to revise
- Live preview — starts your dev server and opens an embedded browser to verify changes
- Parallel sessions — each session gets its own Git worktree for isolated work
- Remote sessions — run on Anthropic’s cloud infrastructure, survives closing your laptop
- SSH sessions — connect to remote machines, cloud VMs, or dev containers
Permission Modes in Code
Code offers four levels of autonomy:
| Mode | Behavior |
|---|---|
| Ask permissions | Claude asks before every edit and command |
| Auto accept edits | File edits auto-apply; commands still require approval |
| Plan mode | Claude analyzes and plans without modifying anything |
| Bypass permissions | Full autonomy, no prompts (sandboxed environments only) |
Best for: writing, testing, running, and deploying code. Building features, fixing bugs, refactoring, reviewing PRs.
Configuration and Setup Files
This is where the modes diverge most sharply. Chat uses a single config file. Code uses a layered hierarchy. Cowork inherits from both.
Chat Mode Configuration
Chat mode uses one file for MCP server configuration:
~/Library/Application Support/Claude/claude_desktop_config.jsonThis is where you define MCP servers for the Chat tab. These servers are not shared with Code mode — they live in a completely separate configuration namespace.
After editing, you must fully quit Claude (Cmd+Q) and reopen it. The config only loads at startup.
Code Mode Configuration
Code mode uses a hierarchical settings system with multiple scopes:
Precedence (highest to lowest):
1. Managed settings (IT-deployed, MDM)
2. Command line arguments
3. Local settings → .claude/settings.local.json
4. Project settings → .claude/settings.json
5. User settings → ~/.claude/settings.jsonEach scope serves a different audience:
| Scope | Path | Shared with team? |
|---|---|---|
| User |
~/.claude/settings.json |
No |
| Project |
.claude/settings.json |
Yes (git-committed) |
| Local |
.claude/settings.local.json |
No (gitignored) |
| Managed |
OS-level plist/registry or managed-settings.json |
Yes (IT-deployed) |
Settings control permissions, environment variables, hooks, sandboxing, model selection, and more. Array settings merge across scopes (concatenated and deduplicated). More specific scopes override less specific ones.
Memory: CLAUDE.md
CLAUDE.md files are persistent instruction files that Claude loads at the start of every session. They’re the project’s institutional memory — coding conventions, architectural decisions, workflow preferences.
| Scope | Path |
|---|---|
| User-wide |
~/.claude/CLAUDE.md |
| Project |
CLAUDE.md or .claude/CLAUDE.md |
Both Chat and Code read CLAUDE.md files, making them the bridge between modes. Write your project guidelines once, and they apply everywhere.
Code mode also supports auto-memory — a persistent directory at ~/.claude/projects/<project-path>/memory/ where Claude saves patterns, decisions, and learnings across sessions.
MCP Server Configuration
MCP (Model Context Protocol) servers extend Claude’s capabilities with external tools. Each mode handles them differently:
Chat mode: Configure in claude_desktop_config.json. Uses a flat JSON structure with an mcpServers object. Servers configured here do not appear in Code mode.
Code mode: Two locations:
-
User-level:
~/.claude.json— available across all projects -
Project-level:
.mcp.jsonin the repository root — shared with your team when committed
You can import Chat’s MCP servers into Code with:
claude mcp add-from-claude-desktopCowork mode: Supports connectors (MCP servers with GUI setup) and inherits MCP configuration from the Code mode settings.
Other Configuration Files
| File | Location | Purpose |
|---|---|---|
.claude/launch.json |
Project root | Dev server configuration for live preview |
~/.claude/agents/ |
User directory | Custom subagent definitions (Markdown + YAML frontmatter) |
.claude/agents/ |
Project directory | Project-specific subagent definitions |
~/.claude/scheduled-tasks/ |
User directory | Scheduled task definitions (SKILL.md files) |
~/.claude/keybindings.json |
User directory | Custom keyboard shortcuts |
Storage and Data
Chat: Conversations sync to Anthropic’s servers (same as claude.ai). Subject to standard data retention policies.
Cowork: Conversation history stored locally on your device. Not captured in audit logs or data exports. The VM sandbox provides process isolation.
Code: Session history stored locally. Configuration files are automatically backed up with timestamps (retains the 5 most recent). Git worktrees for parallel sessions live in <project-root>/.claude/worktrees/.
Choosing the Right Mode
The decision tree is straightforward:
- Need to write or modify code? Use Code.
- Need sustained autonomous work on documents, research, or data? Use Cowork.
- Need a quick answer or conversation? Use Chat.
The modes aren’t competing — they’re complementary. Chat for the quick question about an API. Cowork for the market research report. Code for the feature implementation. All three share the same Claude intelligence, just with different levels of access and autonomy.
The real power comes from understanding that they share configuration where it matters (CLAUDE.md, connectors) while maintaining separation where it’s needed (MCP servers, permissions, file access). Set up your CLAUDE.md files well, configure your MCP servers in the right places, and each mode becomes a natural extension of the others.