Move your team from Claude Cowork to Claude Code.
Each person gets a short interview, then a personalized step-by-step guide showing exactly where their saved work, prompts, and projects land in Claude Code — and the few things that need a manual step, walked through. You send one invite; nobody becomes the help desk, and nothing in Claude Cowork is changed or cancelled. Want to see where you’re paying for both first? Run the free audit.
Both products implement the open Agent Skills standard (agentskills.io): a SKILL.md with YAML frontmatter plus optional scripts and references, auto-loaded when relevant or invoked with `/skill-name`. Cowork ships a bundle under the `anthropic-skills:*` namespace (pdf, docx, pptx, xlsx, skill-creator, consolidate-memory, setup-cowork) and exposes installed-plugin skills the same way Claude Code does. A skill authored for Claude Code (`.claude/skills/<name>/SKILL.md`) will run essentially unchanged in Cowork if packaged as a plugin. The skill-creator skill is the recommended way for non-developers to build skills in Cowork; Claude Code users can hand-author the SKILL.md.
- Warning: Cowork does not give non-devs a project-level `.claude/skills/` directory to drop files into — skills are typically installed as plugins or created via the skill-creator skill, not by hand-editing a checked-in folder.
- Warning: Some Claude Code skill frontmatter keys that depend on terminal idioms (e.g., `shell`, certain `allowed-tools` patterns) may behave differently in Cowork's sandbox where tools have different names (`mcp__workspace__bash` vs `Bash`).
- Warning: Slash-command discovery in Cowork is via the in-app picker; in Claude Code it's `/skills` and tab completion.
Both products can run agentic work without an attached interactive session. Claude Code v2.1.139+ has Agent View (research preview) for dispatching and monitoring many background sessions in parallel. Cowork has the `mcp__scheduled-tasks__create_scheduled_task` MCP plus the Dispatch companion feature, which lets you trigger a Cowork or Claude Code session from your phone (e.g., 'check my email every morning at 8am and summarize'). A developer who wants a non-dev to run unattended automations should set them up via Cowork's scheduled-tasks MCP and Dispatch; a Cowork user graduating to Claude Code should switch to Agent View and `claude --resume`.
- Warning: Claude Code Agent view is a research preview, while Cowork is generally available (GA on 2026-04-09); Dispatch is the newer companion surface and its availability, naming, and plan gating may still change.
- Warning: Cowork scheduled tasks run inside the desktop app and require the app to be reachable (or Anthropic-cloud-hosted depending on the task type); Claude Code background agents run on the user's machine or on Anthropic-managed infra depending on the surface.
- Warning: Dispatch is a separate product surface (phone-driven) — there's no exact Claude Code equivalent for triggering from mobile other than the Claude Code iOS research preview.
Both products expose the same Read, Write, and Edit primitives from the Claude Agent SDK, operating on real files on the user's machine. In Claude Code the working directory is wherever you launched `claude`; in Cowork the user explicitly grants the agent access to one or more 'connected folders' from a folder picker. Outside of those folders, Cowork file ops return a 'outside this session's connected folders' error and prompt the user to authorize the directory. A developer onboarding a non-dev should pre-add the relevant folder(s) (Downloads, Documents/Work, etc.) to the Cowork workspace; a Cowork user moving to Claude Code gets implicit access to the cwd and below.
- Warning: Cowork sandboxes file access to user-approved folders; Claude Code by default can touch anything the OS user can, subject to permission mode.
- Warning: Cowork file changes are real and irreversible on the user's disk — there is no full git-style checkpoint rewind like Claude Code's VS Code 'Rewind code' checkpoint.
- Warning: Plan mode (`/plan` or initialPermissionMode) is a Claude Code concept; Cowork's permission UX is a per-action 'allow/deny' prompt with no separate plan surface.
Both products are interactive agentic conversations with the same underlying Claude Agent SDK loop, but the surfaces differ: Claude Code is a terminal REPL launched with `claude` (plus a VS Code panel and JetBrains plugin), while Cowork is a native macOS/Windows desktop app where the same agent runs inside a chat window aimed at non-developers. A developer setting up a non-technical colleague should install Cowork from claude.com/product/cowork and demonstrate the chat window as the equivalent of a `claude` session; a Cowork user graduating to Claude Code should `npm install -g @anthropic-ai/claude-code` (or use the VS Code extension) and learn the slash-command surface. Both honor the same Anthropic subscription and share usage limits.
- Warning: Claude Code's full `/`-command set (e.g., `!`-prefixed bash, `@`-mention with line ranges, plan-mode toggle) is not present in Cowork — Cowork exposes a smaller, curated slash-command surface aimed at end-users.
- Warning: Cowork has no `--resume` flag; conversations are listed in the desktop UI's history sidebar instead of via CLI flags.
- Warning: There is no shared session continuity between Claude Code and Cowork — `claude --resume` resumes only CLI/VS Code sessions, not Cowork chats.
Both products are MCP hosts and speak the same Model Context Protocol. In Claude Code, MCP servers are added via `claude mcp add` (stdio, HTTP, or SSE transport) and managed in-session with `/mcp`. In Cowork, the same protocol is exposed under the user-facing name 'connectors' and managed through the desktop app's Connectors UI; native connectors include Google Drive, Gmail, Notion, Slack, GitHub, Figma, plus enterprise connectors (Docusign, FactSet, etc.). The same backing MCP server (e.g., a Slack MCP) can be used in both places — only the UI for adding and authorizing the connection differs.
- Warning: Cowork connectors are usually OAuth-authorized inside the desktop app's UI; Claude Code typically expects you to supply credentials/headers on the `claude mcp add` command line.
- Warning: Per-skill/per-subagent `mcpServers` allowlists exist in Claude Code's frontmatter; Cowork generally exposes all installed connectors to the active session without granular per-skill scoping.
- Warning: Some local-stdio MCP servers that Claude Code can spawn directly (e.g., a Postgres MCP binary on your PATH) won't work inside Cowork's sandboxed VM unless the binary is bundled.
Both products draw from the same Anthropic frontier lineup (as of June 2026: Opus 4.8, Sonnet 4.6, Haiku 4.5) and share the user's Pro/Max/Team/Enterprise usage quota. Claude Code exposes `/model` to switch mid-session and `opusplan` to plan with Opus and execute with Sonnet. Cowork exposes a model picker in the chat composer; the available models depend on the user's plan tier (Pro typically gets Sonnet, Max gets Opus access). Quota burned in Cowork counts against the same weekly/session limits as Claude Code on that subscription.
- Warning: There is no `opusplan`-style automatic plan/execute split in Cowork — model selection is a single per-message choice.
- Warning: Per-skill `model:` frontmatter overrides work in both, but the Cowork UI typically does not expose this to end-users.
- Warning: Heavy Cowork usage can exhaust the same weekly cap that limits Claude Code, surprising users who think the two products have separate quotas.
Claude Code uses CLAUDE.md memory files (user `~/.claude/CLAUDE.md`, project `./CLAUDE.md`, local `./CLAUDE.local.md`) that auto-load on every turn; Cowork's equivalent is a Project plus a connected workspace folder. In Cowork, you create a Project, attach a folder (or several) from your machine via 'Add folder', and Claude updates a project memory roughly every 24 hours based on conversations. A developer migrating a non-dev colleague should treat the Cowork Project's instructions field as the CLAUDE.md analogue and pin key facts there; a Cowork user moving to Claude Code should run `/init` in the repo to scaffold a CLAUDE.md.
- Warning: Cowork memory is project-scoped and refreshed on a daily cadence — it does NOT inject every turn the way CLAUDE.md does, so don't rely on it for hard rules; pin those in the project's instructions field instead.
- Warning: Cowork standalone (non-Project) chats have no persistent memory across sessions, while Claude Code always reads CLAUDE.md if present.
- Warning: CLAUDE.md is plain text checked into git; Cowork's memory lives in the Anthropic-managed Project and isn't directly editable as a file.
Both products use the same plugin concept: a bundle of skills, sub-agents, MCP servers, slash commands, and hooks distributed via marketplaces. Cowork ships curated, role-based plugins (sales, finance, legal, marketing, HR, engineering, design, operations, data analysis) that pre-configure the right skills and connectors per job function. Claude Code plugins are typically installed via `/plugin` from a Git repo, URL, or local path. A developer onboarding a non-dev should install the role-matched Cowork plugin during setup (the `setup-cowork` skill walks through this); a Cowork user moving to Claude Code can install equivalent or developer-oriented plugins via `/plugin`.
- Warning: Cowork's plugin marketplace UI is curated by Anthropic and partners; Claude Code accepts arbitrary GitHub repos and URLs, so the threat model is different — a Cowork user expecting marketplace curation should be careful with arbitrary Claude Code marketplaces.
- Warning: Some Cowork plugins are tightly coupled to its connectors and the desktop UX; they may not load or do anything useful inside Claude Code.
- Warning: Plugin installation scopes (`user`, `project`, `local`) are a Claude Code concept; Cowork installs are user-scoped to the desktop app.
Claude Code's Bash tool runs commands natively on the user's machine in the cwd, gated by the active permission mode and per-command allow/deny patterns in `settings.json`. Cowork's equivalent is `mcp__workspace__bash`, which executes inside an isolated Linux VM with the user's connected folders mounted at `/sessions/<session>/mnt/<folder>/`; the host OS (often Windows or macOS) is NOT directly reachable. A developer should remember that Cowork bash is POSIX-only — scripts that depend on the host's installed binaries, PATH, or services will not run there. A Cowork user moving to Claude Code gets a real local shell but must opt into permission modes (`default`/`acceptEdits`/`bypassPermissions`).
- Warning: Each Cowork bash call is independent (no cwd or env carryover between calls); Claude Code's `!` shortcut and Bash tool also lack cross-call shell state, but in Claude Code that state lives on the real host so it feels less surprising.
- Warning: Cowork bash has a per-call wall-clock timeout and a noticeable workspace boot lag on the first call (the guest VM must boot and provision before the first command runs); Claude Code's Bash tool runs on the already-running host with no comparable hard wall-clock cap.
- Warning: Cowork's mount paths are Linux (`/sessions/.../mnt/...`) even when the user is on Windows — paths inside the VM and on the host differ, so don't paste Windows paths into bash and vice versa.
Both products expose slash commands as the primary way to invoke skills and built-in actions. Claude Code has a large built-in set (`/help`, `/clear`, `/compact`, `/context`, `/cost`, `/model`, `/init`, `/review`, `/agents`, `/plugin`, `/skills`, `/mcp`, `/usage`, `/permissions`, etc.) plus user/project skill commands. Cowork exposes a much smaller built-in set focused on end-user needs and surfaces installed skills (including anthropic-skills like `/pdf`, `/docx`, `/pptx`, `/xlsx`, `/skill-creator`, `/setup-cowork`) through the same `/`-prefix UI. Both use a slash-prefix picker; the Cowork picker is a GUI list rather than tab-complete.
- Warning: Power-user CLI commands like `/cost`, `/context`, `/usage`, `/doctor`, `/install-github-app` are Claude Code-only — Cowork users see usage in their account page, not via a slash command.
- Warning: Custom-command files at `.claude/commands/*.md` are a Claude Code concept; in Cowork the equivalent is installing a skill or plugin.
- Warning: Cowork's slash menu typically uses plugin-namespaced names (`anthropic-skills:pdf`) for bundled skills; Claude Code uses the bare skill name.
Both products use the same sub-agent primitive from the Claude Agent SDK: spawn a delegated worker with its own context window, system prompt, tool allowlist, and model, then receive a summary back into the orchestrator's context. In Claude Code this is exposed via the Task tool plus `.claude/agents/<name>.md` definition files and the `/agents` slash command. In Cowork the same Task tool is exposed (TaskCreate, TaskList, TaskGet, TaskUpdate, TaskStop) and plugin/role bundles can ship pre-defined sub-agents. A developer wanting a non-dev to delegate research should install a plugin that ships a research sub-agent; in Claude Code that same developer would author an agent .md file.
- Warning: Hand-authoring sub-agent .md files is a Claude Code workflow — Cowork users typically get sub-agents via plugins, not by editing files in `.claude/agents/`.
- Warning: The `memory` frontmatter field on sub-agents (persistent MEMORY.md directory) is documented for Claude Code; Cowork's memory story is Project-level, not per-sub-agent.
- Warning: Sub-agent isolation modes (`isolation`, `background`) and effort levels are exposed to Claude Code skill/agent authors but are largely abstracted away in Cowork.
Both products are bundled into the same Anthropic consumer/business subscriptions and share usage quotas. As of July 2026, Cowork is generally available on macOS and Windows (it reached GA on 2026-04-09, exiting the earlier research preview), with a Linux build in beta; it is included for all paid plans — Pro, Max, Team, and Enterprise (Free tier excluded). Pro ($20/mo or $17/mo annual) unlocks both Claude Code and Cowork; Max 5x ($100) and Max 20x ($200) scale usage proportionally. Team (Standard $25/seat monthly or $20 annual, Premium $125/seat monthly or $100 annual; 5-seat minimum, 150 maximum) and Enterprise tiers also include Cowork, with the enterprise rollout adding admin controls to manage feature access, spend, and usage across the org, plus private plugin marketplaces and connectors (e.g., Slack, Chrome). Quota burned in either product counts against the same weekly caps; setting `ANTHROPIC_API_KEY` overrides plan-based auth in Claude Code but is not applicable to Cowork's GUI flow.
- Warning: Cowork is GA on macOS/Windows but the Linux desktop build is still beta; plan gating and naming can still evolve, so confirm current inclusions on the pricing page.
- Warning: Free-tier Claude.ai users cannot access either product — both require at least Pro.
- Warning: Heavy Cowork use can starve a developer's Claude Code budget on the same subscription — Anthropic documents that Cowork tasks consume MORE of the shared usage allocation than regular chat because multi-step tasks are computationally intensive; in Team/Enterprise this may need separate quota tracking via the admin console.
- Warning: Earlier enterprise-launch materials named connectors like Docusign and FactSet; the current Cowork product page lists only generic connector support (Slack, Chrome) and private plugin marketplaces — verify any specific connector need before promising it in a migration plan. Claude Code does not ship those connectors out of the box.