Cursor vs Windsurf (Devin Desktop) vs Claude Code: Editors, Agents, Rules, MCP and Pricing Compared
A comparison of Cursor, Windsurf (now documented as Devin Desktop) and Claude Code based on their official docs: editor integrations, terminal and agent workflows, rules and instruction files, MCP setup and current pricing pages.
How this comparison was made: it's a documentation-based comparison, not a benchmark. Every product fact below comes from the vendor's official docs or pricing pages, which we read on 2026-11-05 and link inline. We didn't run hands-on speed, quality or reliability tests, so this article makes no claims about which tool writes better code. These products change often. Check the linked pages before you decide.
A Note on the Name "Windsurf"
Windsurf's documentation URLs (for example docs.windsurf.com/windsurf/cascade/memories) now redirect to Devin documentation at docs.devin.ai, and windsurf.com/pricing redirects to devin.ai/pricing (checked 2026-11-05). That documentation calls the editor Devin Desktop and its local agent Devin Local. The Linux install notes say repository URLs "still use the pre-rebrand windsurf naming, but the package is now called devin-desktop" (Devin Desktop getting started, checked 2026-11-05). Cascade, the agent long associated with Windsurf, is now labelled "legacy": per the docs, "Devin Desktop no longer starts new Cascade conversations" (Cascade (legacy), checked 2026-11-05).
So in this article, "Windsurf" means the product the current docs describe as Devin Desktop.
At a Glance
| Cursor | Windsurf / Devin Desktop | Claude Code | |
|---|---|---|---|
| Primary form | Desktop editor with built-in Agent | Desktop IDE with the Devin Local agent | Agentic coding tool available in terminal, IDEs, desktop app and web |
| Other surfaces (documented) | CLI (agent), cloud agents, JetBrains via ACP | Devin CLI (shares Devin Local's harness), JetBrains via Devin ACP | VS Code extension, JetBrains plugin, desktop app, web, Slack, GitHub Actions / GitLab CI |
| Project instruction files | .cursor/rules/*.mdc, AGENTS.md (root + subdirectories) | .devin/rules/*.md, AGENTS.md; legacy .windsurf/rules, .windsurfrules imported | CLAUDE.md, .claude/rules/*.md; reads AGENTS.md when no CLAUDE.md exists |
| MCP config | .cursor/mcp.json, ~/.cursor/mcp.json | .devin/mcp_config.json (+ local and user files) | claude mcp add …; project scope in .mcp.json |
| MCP transports | stdio, SSE, Streamable HTTP; OAuth | stdio, Streamable HTTP, SSE; OAuth | HTTP (recommended), SSE (deprecated), stdio; OAuth |
| Agent Skills (SKILL.md) | Yes (.cursor/skills, .agents/skills) | Yes (SKILL.md folders, per Devin Local customizations docs) | Yes (.claude/skills) |
| Pricing page | cursor.com/pricing | devin.ai/pricing | claude.com/pricing |
Sources for each row are cited in the sections below (all checked 2026-11-05).
1. Editor Integrations
Cursor is a desktop editor with Agent built in (opened in a side pane). Cursor also documents a JetBrains integration that runs Cursor's agent inside IntelliJ IDEA, PyCharm, WebStorm and other JetBrains IDEs over the Agent Client Protocol (ACP). That integration requires a paid Cursor plan and JetBrains' AI Assistant plugin (checked 2026-11-05).
Windsurf / Devin Desktop is a standalone IDE for macOS, Windows and Linux. Its setup guide covers importing VS Code or Cursor settings (getting started, checked 2026-11-05). For JetBrains, the docs say "The Windsurf JetBrains plugin is in maintenance mode" and recommend switching to Devin over ACP (Windsurf Plugins, checked 2026-11-05).
Claude Code isn't an editor. It runs alongside one. Its overview (checked 2026-11-05) documents a terminal CLI, a VS Code extension (also installable in Cursor), a JetBrains plugin (which requires the CLI), a standalone desktop app and a web version. The docs say each surface "connects to the same underlying Claude Code engine, so your repo's CLAUDE.md files, settings, and MCP servers work across all of them."
What this means for you: if you want AI built into the editor itself, Cursor and Devin Desktop are editors. If you want to keep your current editor (VS Code, JetBrains, or a terminal editor like Neovim), Claude Code's CLI and extensions, or Cursor's and Devin's ACP integrations for JetBrains, are the documented routes.
2. Terminal and Agent Workflows
Cursor
- CLI: the Cursor CLI runs as
agent. It has an interactive mode and a non-interactive "print mode" (agent -p "…") that the docs describe as being for "scripts, CI pipelines, or automation" (checked 2026-11-05). - CLI uses the same config: the CLI uses the same
.cursor/rulessystem, readsAGENTS.mdandCLAUDE.mdat the project root, and respects yourmcp.json(Using the CLI, checked 2026-11-05). - Editor Agent: Agent in the editor can search, edit files, run terminal commands and use a browser, with local checkpoints (Agent overview, checked 2026-11-05).
- Cloud agents: Cursor documents cloud agents.
Windsurf / Devin Desktop
- Devin Local: the agent runs on your machine and is described as "our next-generation agent harness shared with Devin CLI." It supports subagents and OS-level sandboxing (Devin Local, checked 2026-11-05).
- Terminal commands: the agent can run terminal commands on its own. Allow/ask/deny rules and session modes (Code, Smart, Bypass Permissions) control approval (Terminal, checked 2026-11-05).
- Cloud: Devin's pricing page lists access to cloud agents ("Devin Cloud") on the Pro plan (checked 2026-11-05).
Claude Code
- CLI-first: the terminal CLI is the full-featured surface. The docs show piping and scripting with
claude -p(for example,git diff main --name-only | claude -p "review these changed files…") (overview, checked 2026-11-05). - CI integrations: documented for GitHub Actions and GitLab CI/CD.
- Parallel and scheduled work: the docs cover subagents, background agents, cloud and desktop scheduled tasks, and a web surface for long-running tasks.
What this means for you: all three now document both an interactive agent and a scriptable or non-interactive path. The real difference is where you spend your day: Cursor and Devin Desktop are editor-first with a CLI available, while Claude Code is terminal-first with editor integrations.
3. Rules and Instruction Files
| Cursor | Windsurf / Devin Desktop | Claude Code | |
|---|---|---|---|
| Main format | .cursor/rules/*.mdc with description / globs / alwaysApply frontmatter | .devin/rules/*.md with optional trigger: frontmatter | CLAUDE.md (project root or .claude/CLAUDE.md) |
| Scoped rules | Always / by glob / by relevance / manual | always_on / glob / model_decision / manual | .claude/rules/*.md with paths: frontmatter |
| AGENTS.md | Root and subdirectories | Root and subdirectories (also AGENTS.local.md, AGENT.md) | Read only when no CLAUDE.md/CLAUDE.local.md exists in the working directory or above (v2.1.277+), configurable |
| Personal / global | User Rules in Customize | ~/.devin/rules/, ~/.devin/global_rules.md | ~/.claude/CLAUDE.md, ~/.claude/rules/, CLAUDE.local.md |
| Team / org | Team Rules (Team & Enterprise) | Admin settings | Managed policy CLAUDE.md |
| Legacy files | .cursorrules isn't mentioned in current docs | .windsurf/rules/*.md, .windsurf/global_rules.md, .windsurfrules imported by default | — |
Sources: Cursor Rules; Devin Local customizations; Claude Code memory (all checked 2026-11-05).
Examples of each format, from the docs' structures (illustrative content):
Cursor .cursor/rules/components.mdc
---
description: React component conventions
globs: src/components/**/*.tsx
alwaysApply: false
---
- Named exports; props typed with an interface
- Tailwind classes only; no inline styles
Devin Desktop .devin/rules/components.md
---
trigger: glob
globs: "src/components/**/*.tsx"
---
- Named exports; props typed with an interface
- Tailwind classes only; no inline styles
Claude Code .claude/rules/components.md
---
paths:
- "src/components/**/*.tsx"
---
- Named exports; props typed with an interface
- Tailwind classes only; no inline styles
Sharing one file across tools: a root AGENTS.md is read by Cursor and Devin Desktop. Claude Code reads it when there's no CLAUDE.md, and its docs also describe importing AGENTS.md from a CLAUDE.md. Cursor's CLI reads both AGENTS.md and CLAUDE.md at the root. Keep shared conventions in AGENTS.md, and put tool-specific scoping in each tool's own rules folder.
Ready-made rule content: Cursor rules, Windsurf rules, Claude Code rules. For the Cursor format in depth, see How to Write Cursor Rules.
4. MCP Support
All three document Model Context Protocol support. The setup differs:
Cursor (MCP docs, checked 2026-11-05)
- Config files:
.cursor/mcp.jsonper project or~/.cursor/mcp.jsonglobally. You can also install from Customize or the Cursor Marketplace. - Transports: stdio, SSE and Streamable HTTP.
- Auth: OAuth for remote servers (authorization code flow with PKCE).
- Variables:
${env:NAME}interpolation in config.
Windsurf / Devin Desktop (MCP docs, checked 2026-11-05)
- Config files:
.devin/mcp_config.json(committed),.devin/mcp_config.local.json(gitignored),~/.config/devin/mcp_config.json(user). - Transports: stdio, Streamable HTTP and SSE, with OAuth for each.
- Approval: by default the agent asks for approval before calling any MCP tool. Enterprise admins can configure MCP registries.
Claude Code (MCP docs, checked 2026-11-05)
- Adding servers:
claude mcp add --transport http <name> <url>for remote servers, orclaude mcp add <name> -- <command>for local stdio servers. SSE is marked deprecated. - Scopes: local (default), project (
.mcp.json, shared via git) and user. - Auth and status: OAuth via
/mcporclaude mcp login./mcpalso shows server status.
For example, GitHub's official MCP server documents a hosted endpoint (https://api.githubcopilot.com/mcp/) and a Docker image, with per-host guides for Cursor, Claude Code and Windsurf (github/github-mcp-server, checked 2026-11-05). Browse more servers in our MCP directory, for example GitHub and Filesystem.
5. Pricing (checked 2026-11-05)
Prices below were copied from the official pages on 2026-11-05. They exclude tax, are subject to change, and leave out usage-limit details. Always confirm on the vendor page before buying.
Cursor
- Plans: Cursor's Models and Pricing docs and pricing page list Free ($0), Plus ($8/mo), Premium ($30/mo), Super ($100/mo) and Ultra ($200/mo). Teams is $30, $100 or $200 per seat/month, and Enterprise is custom.
- Bundle: the docs say Cursor "is sold as part of The X Subscription".
- Third-party models: not included in the usage pool. They're available on Premium and above at API list price, and the Plus plan is limited to Cursor's own models (Grok 4.x and Composer 2.5).
- Legacy plans: older plans (Pro, Pro+, Ultra, Start, Teams Standard/Premium seats) keep working as legacy plans.
Windsurf / Devin Desktop
- Plans: devin.ai/pricing (where
windsurf.com/pricingnow redirects) lists Free ($0), Pro ($20/month), Max ($200/month), Teams ($80/month for the team plan plus $40/month per full dev seat) and Enterprise (contact sales). - Overages: extra usage beyond quotas is billed at API pricing.
Claude Code
- Plans: claude.com/pricing lists Claude Code as included in Pro ($17/month billed annually, or $20 billed monthly), Max ($100/month) and Ultra ($200/month), but not in Free. Team Standard seats ($20/seat/month billed annually, $25 monthly) also include it.
- Usage limits: these apply on all plans.
- API billing: the Claude Code overview notes that most surfaces need a Claude subscription or an Anthropic Console account, which is billed by API usage.
Usage-based pricing means the effective cost depends heavily on which models you use and how much. Compare against your own expected usage, not just the headline prices.
How to Choose
These questions follow from the documented differences, not from performance testing:
- Do you want an AI-first editor, or to keep your current editor? Cursor and Devin Desktop are editors. Claude Code adds an agent to your terminal, VS Code, JetBrains, desktop or browser.
- Is your workflow terminal- or CI-heavy? All three have a scriptable CLI path. Claude Code's docs put the most emphasis on terminal, piping and CI usage.
- Do you need fine-grained rule scoping? All three support path-scoped rules: Cursor
globs, Devintrigger: glob, Claude Codepaths. Cursor and Devin also offer description-based (model-decided) activation. - Which models do you need? Model access is tied to each vendor's plans. Check the current model lists and pricing pages, since availability has changed recently.
- Team administration? Compare Team Rules (Cursor), MCP registries and admin settings (Devin), and managed
CLAUDE.md/settings (Claude Code) against your org's requirements.
The best way to decide is to run the same real task in your own repository with each tool you're considering, using identical instructions (for example, a shared AGENTS.md), and compare the diffs.
Using More Than One
Many teams mix tools, for example an editor-based agent for interactive work and a CLI agent in CI. Keep the shared rules in a root AGENTS.md (read by all three under the conditions above), and keep tool-specific files (.cursor/rules, .devin/rules, .claude/rules) small and scoped.
Official Sources (checked 2026-11-05)
- Cursor: Rules · MCP · Skills · CLI overview · Using the CLI · Agent overview · JetBrains · Models and Pricing · Pricing
- Windsurf / Devin Desktop: Getting started · Customizations/rules · MCP · Devin Local · Terminal · Windsurf Plugins (JetBrains) · Pricing
- Claude Code: Overview · Memory / CLAUDE.md · MCP · Skills · Pricing
Need starter rules for whichever tool you pick? Browse Cursor rules, Windsurf rules or Claude Code rules, or check prompt quality with the Prompt Grader.
Related Articles
How to Create Claude Code Skills: A SKILL.md Guide with a Worked Example
Create an Agent Skill for Claude Code: directory layout, SKILL.md frontmatter rules, supporting files and scripts, where Claude Code discovers skills, how they are invoked, failure handling, and how skills differ from MCP servers.
Agent Skills vs MCP Servers: What's the Difference?
Agent Skills (SKILL.md folders) teach an AI agent how to do a task. MCP servers give it tools and data. What each one is, how they work together, and when to use which, with current GitHub and filesystem MCP setup examples.
AGENTS.md vs CLAUDE.md: Which AI Coding Tools Read Which Instruction File
A cross-tool guide to AGENTS.md: how Cursor, Claude Code, Gemini CLI, Kiro, Devin Desktop (Windsurf), GitHub Copilot and Antigravity read it, how it relates to CLAUDE.md, GEMINI.md and tool-specific rules, and a shared-file pattern with caveats.