Move your team from Claude Code to Windsurf.
Each person gets a short interview, then a personalized step-by-step guide showing exactly where their saved work, prompts, and projects land in Windsurf — and the few things that need a manual step, walked through. You send one invite; nobody becomes the help desk, and nothing in Claude Code is changed or cancelled. Want to see where you’re paying for both first? Run the free audit.
Cascade's agent loop maps to Claude Code's core edit loop. Cascade Code mode (creates/modifies files, runs commands, installs dependencies) → Claude Code's default agent behavior with Read/Write/Edit/Bash tools and per-edit diff review. Cascade's built-in planning (a background planning agent that drafts an approach before acting — not a separate user-selectable mode) → Claude Code plan mode (permission mode `plan`: read-only exploration, then an approvable plan; in the VS Code extension the plan opens as a full Markdown document you can comment on inline before Claude proceeds). Cascade Chat mode (read-only Q&A about your codebase or general coding) → running Claude Code in plan mode or just asking without approving edits. Cascade's named checkpoints/snapshots and prompt revert → Claude Code checkpoints ('Rewind code to here' / 'Fork conversation from here'). Multiple simultaneous Cascades with worktree isolation → multiple Claude Code sessions, each launchable in an isolated worktree via `claude --worktree <name>` (`-w`). Timing: Cascade is available only through 2026-07-01 (EOL) following the June 2, 2026 Devin Desktop rebrand, with Devin Local as its successor — migrate scripted Cascade workflows before then.
- Warning: Cascade's flow awareness (watching your recent in-editor actions to infer intent) has no Claude Code analog — the CLI sees only what it reads or what you @-mention; the VS Code extension shares your current selection/open file, which recovers part of this.
- Warning: Cascade's 20-tool-calls-per-prompt cap with the credit-consuming 'Continue' button does not exist in Claude Code; sessions run until done within your plan's usage windows.
- Warning: Cascade prompt reverts are documented as irreversible; Claude Code checkpoints let you fork the conversation instead of destroying history.
- Warning: Claude Code is terminal-first: the editor-embedded panel experience requires installing the VS Code extension; bare-CLI users approve whole diffs in the terminal rather than clicking per-hunk.
Devin cloud (each session on its own VM with desktop/browser/computer use, keeps working after you close the laptop, managed in the Agent Command Center) maps to Claude Code on the web: sessions run on Anthropic-managed cloud sandboxes at claude.ai/code against connected GitHub repos, persist after you close the browser, and are monitorable from the Claude mobile app. The local↔cloud handoff exists on both sides: Windsurf's one-click 'Cascade plans locally → Devin implements in the cloud' corresponds to Claude Code's `claude --remote` (push a task to the cloud from the terminal) and `--teleport` / VS Code Session history → Remote (pull a cloud session down to continue locally). Configure environments with setup scripts and network-access levels to replicate what Devin's VM preinstalled.
- Warning: Devin's VM has a full desktop and browser with computer use; Claude Code web sandboxes are repo-scoped development environments with configurable-but-restricted network access — GUI-driving workflows don't carry over.
- Warning: Claude Code on the web is a research preview gated to Pro/Max/Team (and Enterprise premium / Chat+Claude Code seats); Devin cloud comes with self-serve Pro/Max/Teams and needs Admin Portal enablement on Enterprise — check your tier maps before promising parity.
- Warning: Devin draws from the shared Windsurf plan quota plus a $50 GitHub-connect credit (which won't transfer); Claude Code web sessions consume your Claude plan's usage windows.
- Warning: Agent Command Center's kanban view and Spaces (bundling sessions, PRs, files per task) have no Claude Code equivalent — the web UI is a session list; GitHub PRs are the organizing artifact.
This is an architectural swap, not a config move. Windsurf/Devin Desktop pre-indexes the entire local codebase (an optimized RAG implementation using proprietary M-Query retrieval to surface relevant snippets at query time); Claude Code maintains NO index — it explores agentically per task with Glob/Grep/Read and gets its persistent bearings from CLAUDE.md. Migrate the intent, not the mechanism: pinned context items (modules, internal frameworks you promoted for retrieval priority) become CLAUDE.md pointers ('API handlers live in src/api/handlers/') or `@path` imports; `.windsurfignore`/`.codeiumignore` exclusions become `Read(...)` deny rules in `.claude/settings.json` for genuinely sensitive paths (and the VS Code extension respects .gitignore for searches by default).
- Warning: No semantic search: on very large monorepos Claude Code's cold-start exploration costs more time/tokens than an index hit, though `.claude/rules/` with paths frontmatter and a good CLAUDE.md close most of the gap.
- Warning: Windsurf remote repository indexing (Teams/Enterprise, multi-repo) has no Claude Code equivalent; multi-repo context in Claude Code is `--add-dir` plus `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1` to load the extra directories' memory files.
- Warning: Windsurf's Knowledge Base (up to 50 Google Docs as team context) has no built-in counterpart — wire a Google Drive MCP server instead.
- Warning: Ignore semantics differ: .windsurfignore hides files from indexing/retrieval; Claude Code permission deny rules hard-block reads (and are enforced, not advisory) — decide which paths need privacy vs noise reduction.
Two viable shapes. (1) Transition-in-place: the Claude Code VS Code extension installs into VS Code forks — Anthropic's docs explicitly name Devin Desktop and Kiro, via the editor's Extensions view or the Open VSX registry — so you can run Claude Code as a panel inside your existing Windsurf/Devin Desktop editor today, keep Tab and your settings, and retire Cascade on your own schedule before the 2026-07-01 EOL. (2) Full exit: move to plain VS Code (or stay terminal-only — `claude` runs in any terminal) and carry over your VS Code-shaped settings/keybindings/extensions. JetBrains users keep a path too: Windsurf's JetBrains plugin (the only plugin with Cascade) maps to Claude Code's JetBrains plugin.
- Warning: If the fork can't install the extension, the documented fallback is running `claude` in the integrated terminal — everything works, minus the graphical panel.
- Warning: Running Claude Code inside Devin Desktop side-by-side with Cascade/Devin Local risks two agents editing the same files — keep one in plan/read-only mode or disable the native agent's auto-apply while transitioning.
- Warning: Windsurf's maintenance-mode plugin family (VS Code, Visual Studio, Vim/Neovim, Jupyter, Chrome/Colab, Eclipse — autocomplete/chat only, no Cascade) mostly has no Claude Code surface equivalent; Vim and Visual Studio users land on the bare CLI.
- Warning: Permissions/config don't share between the products: Claude Code's settings live in ~/.claude/ and .claude/, independent of anything Windsurf configured — auto-execution trust must be re-established via Claude Code's own permission rules.
Honest answer: this does not migrate. Claude Code has no ghost-text completion — the docs' CLI-vs-extension comparison lists tab completion as shell-style command/path completion only, not code suggestions. Windsurf Tab users (Supercomplete multi-line diffs, Tab to Jump, Tab to Import, unlimited on all plans) lose the keystroke-driven surface entirely. Practical mitigations: run the Claude Code VS Code extension inside an editor that still has a completion product (VS Code + GitHub Copilot, or even inside Devin Desktop until you fully exit), and lean on Claude Code's conversation-driven Edit/MultiEdit loop for the multi-line ripple edits Supercomplete used to make.
- Warning: This is the single biggest UX loss on the Windsurf → Claude Code path; warn users explicitly rather than burying it.
- Warning: No BYOK or plugin rebuilds this inside Claude Code itself — completion is simply not in the product; third-party ghost-text extensions (Copilot, Continue, etc.) are separate purchases/installs with their own billing.
- Warning: Windsurf Tab reads terminal activity, Cascade chat history, and (opt-in) clipboard as completion context; nothing in a replacement completion product will replicate that exact context mix.
- Warning: Tab to Import's automatic dependency imports are partially recovered by just asking Claude to fix imports, but that is a conversational round-trip, not a keystroke.
The cleanest translation in this pair: both systems run user shell commands at agent lifecycle events, deliver event context as JSON on stdin, and block pending actions when a pre-hook exits with code 2. Move configs from Windsurf's hooks.json (system/user/workspace, merged) into Claude Code's settings hooks (`~/.claude/settings.json`, `.claude/settings.json`, `.claude/settings.local.json`, managed policy). Event mapping: `pre_read_code` → `PreToolUse` with matcher `Read`; `pre_write_code` → `PreToolUse` with matcher `Edit|Write`; `pre_run_command` → `PreToolUse` with matcher `Bash`; `pre_mcp_tool_use` → `PreToolUse` with matcher `mcp__.*`; `pre_user_prompt` → `UserPromptSubmit`; the `post_*` twins → `PostToolUse` with the same matchers; `post_cascade_response` → `Stop`; `post_cascade_response_with_transcript` → `Stop` (read the JSON's `transcript_path`); `post_setup_worktree` → closest is `SessionStart`. Windsurf's separate `powershell` command field corresponds to writing platform-appropriate hook commands in Claude Code settings.
- Warning: Payload schemas differ entirely: Windsurf sends `agent_action_name`/`trajectory_id`/`tool_info`; Claude Code sends `session_id`/`cwd`/`hook_event_name`/`tool_name`/`tool_input`. Every jq/parsing line in your hook scripts must be rewritten; only the trigger intent ports.
- Warning: Claude Code matchers are tool-name patterns (exact, |-list, or regex) inside each event — Windsurf's twelve named events flatten into fewer Claude Code events plus matchers, so audit that each hook still fires where you expect.
- Warning: Claude Code hooks can do more than block: stdout JSON can deny/allow/ask permissions, inject additionalContext, and hook types include HTTP endpoints, MCP tools, prompts, and agents — none of which Windsurf has; conversely Windsurf has no equivalent of Claude Code's FileChanged or PermissionRequest events.
Both are first-class MCP hosts with the same `mcpServers` config concept. Port Windsurf's `~/.codeium/windsurf/mcp_config.json` entries via `claude mcp add` (or paste JSON with `claude mcp add-json` / into `.mcp.json`): stdio servers copy `command`/`args`/`env` verbatim (`claude mcp add --transport stdio <name> --env KEY=val -- <command> <args>`); remote servers rename `serverUrl` → `url` and add `--transport http` (or `sse`, though SSE is deprecated in Claude Code — prefer HTTP where the server supports it). Choose scopes deliberately: Windsurf's single global config file ≈ Claude Code user scope (`--scope user`, all projects); use project scope (`.mcp.json`, checked in, team-shared with approval prompts) for repo-specific servers — a sharing model Windsurf lacks.
- Warning: Interpolation syntax differs: Windsurf's `${env:VAR_NAME}` becomes `${VAR}` (with `${VAR:-default}` support) in Claude Code configs, and Windsurf's `${file:/path}` has no direct equivalent — move file-sourced secrets to env vars or use Claude Code's `headersHelper` for dynamic auth headers.
- Warning: Cascade's hard cap of 100 total MCP tools doesn't exist in Claude Code, but large tool surfaces still cost context; Claude Code warns at 10,000 output tokens per MCP call (`MAX_MCP_OUTPUT_TOKENS` to raise).
- Warning: OAuth-authenticated servers must re-auth after the move (run `/mcp` to manage authentication); tokens don't transfer.
- Warning: Windsurf's MCP Marketplace one-click installs and `windsurf://` deeplinks have no Claude Code UI equivalent — the path is `claude mcp add` plus the Anthropic Directory for reviewed remote connectors.
Lossy but well-defined: Windsurf's multi-vendor catalog collapses to Anthropic-only. The Claude entries migrate directly — Windsurf's Claude Opus 4.8 Low/Medium/High/XHigh picker variants become `/model opus` plus `/effort low|medium|high|xhigh` (Claude Code exposes effort as a first-class slider, and Opus 4.8/4.7 support the full low/medium/high/xhigh/max range, an unusually clean match for Windsurf's Opus effort-variant SKUs); Claude Sonnet 4.6 → `/model sonnet` (Sonnet 4.6 also supports effort, but only low/medium/high/max — there is no xhigh on Sonnet, so `xhigh` falls back to `high` there); Claude Haiku 4.5 → `/model haiku` (Haiku does not support effort). Windsurf's 'Adaptive' auto-routing roughly corresponds to Claude Code's `opusplan` (Opus for plan mode, Sonnet for execution) or just the per-tier default model. Set defaults via `/model`, `claude --model`, `ANTHROPIC_MODEL`, or the `model` settings key.
- Warning: Hard loss for non-Anthropic users: GPT-5.x, Gemini 3.x, DeepSeek, Kimi, Grok, GLM, and Minimax picks have NO Claude Code equivalent — the CLI runs Anthropic models only (or Anthropic-on-Bedrock/Vertex/Foundry).
- Warning: No free model: Windsurf's SWE-1.6 costs 0 credits on every plan; Claude Code has no zero-cost model and no free plan — the cheapest lane is Haiku within a Pro subscription.
- Warning: Windsurf's in-house SWE-series and Arena tiers (Fast/Hybrid/Frontier routing) have no analog; the closest 'route by task' behavior is opusplan plus per-skill/subagent `model` and `effort` frontmatter overrides.
- Warning: Billing units change shape: per-token credit multipliers (0x–450x) become subscription usage windows or API pay-as-you-go — there is no per-model multiplier to compare against; model the workload instead.
Rules translate well; memories translate conceptually. Workspace rules (`.windsurf/rules/*.md` / `.devin/rules/*.md`) → `CLAUDE.md` plus `.claude/rules/*.md`: `always_on` rules → CLAUDE.md content or `.claude/rules/` files without frontmatter (loaded every session); `glob`-triggered rules → `.claude/rules/*.md` with `paths:` frontmatter (a direct equivalent — loads only when Claude touches matching files); `manual` (@-mention) rules → skills invoked on demand; `model_decision` rules → skills with a `description` Claude matches when relevant. Global rules (`~/.codeium/windsurf/memories/global_rules.md`) → `~/.claude/CLAUDE.md` or `~/.claude/rules/`. The fastest path is documented first-party: Claude Code's `/init` explicitly reads existing `.devin/rules/`, `.windsurfrules`, and AGENTS.md and incorporates them into a generated CLAUDE.md. Windsurf's auto-generated Memories map to Claude Code's auto memory (v2.1.59+, `~/.claude/projects/<project>/memory/`), which Claude likewise writes itself across sessions.
- Warning: Claude Code reads CLAUDE.md, NOT AGENTS.md. Windsurf treats AGENTS.md as a native rules source; in Claude Code you must create a CLAUDE.md containing `@AGENTS.md` as an import (or symlink it — requires Developer Mode/admin on Windows).
- Warning: Memory contents do not transfer: Windsurf memories are machine-local files under ~/.codeium/windsurf/memories/, and Claude Code's auto memory starts empty — promote load-bearing memories into CLAUDE.md text by hand before leaving.
- Warning: Subdirectory AGENTS.md auto-scoping in Windsurf (glob-by-location, no frontmatter) maps to nested CLAUDE.md files that load on demand when Claude reads files in those directories — same idea, different file name.
- Char limits vs adherence: Windsurf enforces 6,000/12,000-char caps; Claude Code loads CLAUDE.md in full but documents that files over ~200 lines reduce adherence — long ported rule sets should be split into path-scoped rules.
Tier mapping for a migrating individual: Windsurf Pro ($20/mo) → Claude Pro ($20/mo monthly, $17 annual — includes Claude Code); Windsurf Max ($200/mo) → Claude Max 20x ($200/mo), with Max 5x ($100/mo) as the intermediate step Windsurf doesn't have; Windsurf Teams ($80 base + $40/user) → Claude Team (Standard seat $20-25/user; Premium seat $100-125/user for heavy Claude Code use); Enterprise → Enterprise on both. API pay-as-you-go exists on both sides as the meter-by-usage escape hatch (Windsurf extra usage bills at API pricing; Claude Code runs directly on an Anthropic API key). Meter shapes: Windsurf's post-March-2026 daily/weekly auto-refreshing quotas correspond loosely to Claude's session-plus-weekly usage windows — both are 'allowance that replenishes', unlike Cursor-style monthly dollar pools.
- Warning: No free tier: the Devin Desktop (ex-Windsurf) Free plan still includes a real local agent (Devin Local — 'light quota to code with agents'); Claude's free plan does NOT include Claude Code at all — free-tier users must start paying or stay behind.
- Warning: Windsurf publishes quota mechanics loosely (daily/weekly refresh) and Claude publishes multiplier language (Pro / Max 5x / Max 20x) with time-based windows — neither is precisely numeric, so do a two-week parallel trial on real workload before committing a team.
- Warning: Unlimited-Tab-on-every-plan is a Windsurf selling point with no Claude Code meaning (no completions product) — drop it from any cost comparison.
- Warning: Devin cloud agent inclusion (Pro and up, shared quota) maps to Claude Code web sessions being included in Pro/Max/Team plans — but both are gated surfaces (Enterprise enablement vs research-preview seat types); verify before counting on background-agent capacity.
Windsurf workflows (`.windsurf/workflows/<name>.md`, invoked manually as `/<name>`) become Claude Code custom commands or skills with the same invocation syntax: drop the markdown body into `.claude/commands/<name>.md` (simplest — custom commands are merged into the skills system and a file there creates `/<name>` directly) or into `.claude/skills/<name>/SKILL.md` with `name`/`description` frontmatter when you want supporting files alongside. Global workflows (`~/.codeium/windsurf/global_workflows/`) → `~/.claude/skills/` or `~/.claude/commands/` for all-project availability. Workflow composition (calling `/other-workflow` as a step) survives as instructions referencing the other skill.
- Warning: Windsurf workflows are strictly manual-only; Claude Code skills can be auto-invoked when Claude judges them relevant — set `disable-model-invocation: true` in the skill frontmatter to preserve the manual-only contract.
- Warning: Windsurf's 12,000-char-per-file cap disappears, but Claude Code's guidance is the opposite trap: skill bodies load on use, so big reference material is fine — yet anything that must be in EVERY session belongs in CLAUDE.md, not a skill.
- Warning: Name collisions with Claude Code's bundled skills (/code-review, /debug, /loop, /verify, /run etc.) are possible — rename ported workflows that shadow built-ins.
- Warning: Windsurf's enterprise system-level workflow directories map to Claude Code plugins or managed settings distribution, not a files-on-disk convention on each machine.
- Windsurf also ships folder-based 'Cascade Skills' (auto-invocable, distinct from Workflows); those map to Claude Code skills nearly one-to-one since both follow the SKILL.md shape — but verify frontmatter keys individually, the supported sets differ.
Map Windsurf's four auto-execution tiers onto Claude Code's permission system: Disabled (approve everything) → `default` mode; Allowlist Only → `permissions.allow` rules like `Bash(npm run *)` / `Bash(git commit *)` in `.claude/settings.json` (wildcards at any position; compound commands matched per-subcommand); Auto (model judges safety, premium models only) → Claude Code's `auto` permission mode (research preview: auto-approves with background safety checks); Turbo (run everything except denylist) → `bypassPermissions` or `dontAsk` mode combined with `permissions.deny` rules. Windsurf deny lists port directly to `permissions.deny` `Bash(...)` patterns. Org-level caps (Teams/Enterprise admins capping max automation and pushing org-wide lists) → managed settings (`managed-settings.json`) whose rules user/project settings cannot override.
- Warning: Pattern semantics differ in detail: Claude Code's `Bash(ls *)` enforces a word boundary, strips wrappers like `timeout`/`nice`, splits compound commands on &&/||/;/| and requires each subcommand to match — Windsurf allowlist entries won't translate character-for-character; re-test each rule.
- Warning: Claude Code layers OS-level sandboxing (filesystem + network isolation for Bash) on top of permissions — Windsurf has no equivalent layer; enabling it tightens behavior beyond what Turbo-tier users are used to, and `autoAllowBashIfSandboxed` changes when prompts appear.
- Warning: `bypassPermissions` is more dangerous than Turbo: it skips most prompts globally (with circuit breakers for rm -rf / and home), and admins can disable it via `disableBypassPermissionsMode` — decide policy before rollout.
- Claude Code ships a built-in read-only command set (ls, cat, grep, git status, etc.) that never prompts in any mode — there is no Windsurf equivalent concept, so 'Disabled'-tier purists should add explicit ask rules if they want prompts on those too.