# Cursor, Claude Code, and Codex vs Devin Desktop (formerly Windsurf)

URL: https://developertoolkit.ai/en/comparison/vs-windsurf/
Description: Devin Desktop, formerly Windsurf, against Cursor, Claude Code and Codex: what could be verified on 2026-09-26 and 2026-10-12, a decision table and a same-task bake-off.

Devin Desktop is the editor formerly called Windsurf: Cognition's pricing page names it and windsurf.com redirects there (checked 2026-10-12). Against Cursor, Claude Code and Codex, the verifiable difference is reach beyond the editor: the big three document headless CI runs, isolated worktrees, MCP and Agent Skills, while Devin Desktop's feature set beyond its plans could not be verified.

Your editor updated itself and now says Devin Desktop. The Windsurf comparison your team bookmarked still describes Cascade and a $12 plan, finance wants to know whether to renew, and two engineers already run Claude Code in the integrated terminal. This page is for the developer who has to pick a tool and the tech lead or CTO who has to defend the choice with evidence rather than an old feature table.

**What we could verify on 26 September and 12 October 2026**

Cognition's own pages (`windsurf.com`, `devin.ai`, `docs.devin.ai`) could not be checked on 2026-09-26. On 2026-10-12 `devin.ai/pricing` was readable (`windsurf.com/pricing` redirects to it), and the plans and the SWE-2 promotion below are verified from it. The rename date and the SWE-2 launch date still come from secondary sources and are named as such. Where a cell says "not verified", we could not check it; it does not mean the feature is missing. Treat any Windsurf-era comparison, including earlier versions of this page, as out of date.

## What you get from this Devin Desktop comparison

- A dated list of what changed when Windsurf became Devin Desktop, with the source and confidence of each claim
- A capability table for Cursor, Claude Code and Codex, checked against the installed CLIs and vendor docs
- A decision table: keep the editor, add a terminal agent beside it, or move
- Three copy-paste prompts for a same-task bake-off on your own repository, plus the gates that score it without reading every diff
- The ways a Devin Desktop comparison goes wrong, and how to recover from each

## What changed when Windsurf became Devin Desktop?

| Claim | Status | Source, date |
| --- | --- | --- |
| The Windsurf editor was renamed Devin Desktop in June 2026 | Secondary | Creeta, June 2026 |
| Cognition's SWE-2 model launched on 2026-09-10 in Devin Desktop and the Devin CLI | Secondary | aipricing.guru, September 2026 |
| Cognition's pricing page is `devin.ai/pricing`, it names Devin Desktop, and `windsurf.com/pricing` redirects to it | Verified | `devin.ai/pricing`, checked 2026-10-12 |
| Plans: Free $0, Pro $20/month, Max $200/month, Teams $80/month base plus $40/month per full dev seat (up to 200 users); SWE-2 is free in Devin Desktop and the Devin CLI through 2026-10-16 | Verified | `devin.ai/pricing`, checked 2026-10-12 |
| A public `CognitionAI/devin-cli` repository exists (created 2026-06-10); its latest version is 3000.11.3, published 2026-09-23 | Verified (existence on 2026-09-26, version on 2026-10-12) | GitHub, checked 2026-09-26 and 2026-10-12 |
| OpenAI's Codex README lists Windsurf among the editors its IDE extension supports | Verified | `openai/codex` README, checked 2026-09-26 |
| Projects keep editor rules in `.windsurf/rules/` with a `trigger` in each file's frontmatter; some already use `.devin/rules/` | Seen in public repositories | GitHub code search, 2026-09-26 |

Two conclusions follow. First, the old "Windsurf is the budget option" argument does not survive the listed prices: a $20 Pro plan sits level with Claude Pro at $20/month (claude.com/pricing, checked 2026-09-26) and Cursor Pro at $20/month (cursor.com, checked 2026-10-12). For every plan side by side, see [plan prices for Claude Code, Codex, Cursor and Copilot](/en/comparison/pricing-analysis/). Second, you are evaluating a product whose roadmap is now Cognition's, so any decision needs a re-check date.

## How do Devin Desktop, Cursor, Claude Code and Codex compare?

| | Devin Desktop | Cursor | Claude Code | Codex |
| --- | --- | --- | --- | --- |
| **Where you work** | Editor (formerly Windsurf); Devin CLI (3000.11.3, 2026-09-23) | Editor, Cloud Agents, CLI | CLI, desktop app, VS Code and JetBrains extensions, web | CLI, IDE extension, desktop app (macOS, Windows), cloud |
| **Default model** | SWE-2 offered, free in Devin Desktop and the Devin CLI through 2026-10-16 (devin.ai/pricing, checked 2026-10-12); default not verified | No single default model; Hobby uses Auto (Cursor, checked 2026-10-12) | Claude Opus 5.5 (v2.1.280 and later) | GPT-6.1 Sol |
| **Headless and CI** | Not verified | `agent -p` (print mode) and Cursor CLI in GitHub Actions | `claude -p`; `anthropics/claude-code-action@v1` | `codex exec`; `openai/codex-action@v1` |
| **Parallel, isolated runs** | Not verified | Worktrees, subagents, Cloud Agents in isolated VMs | `--worktree`, subagents, background sessions | `--worktree`, subagents, cloud tasks |
| **MCP** | Not verified | Yes | `claude mcp add` | `codex mcp add` |
| **Agent Skills** | Not verified | Yes | Yes | Yes |
| **Project instructions** | `.windsurf/rules/` (`.devin/rules/` in some repositories) | Rules; reads `AGENTS.md` and `CLAUDE.md` | `CLAUDE.md`; reads `AGENTS.md` when there is no `CLAUDE.md` (v2.1.277 and later on the Anthropic API, v2.1.281 on Bedrock, Google Cloud and gateways) | `AGENTS.md` |
| **Pull request review** | Not verified | Bugbot | `/code-review`; managed Code Review (Team and Enterprise; generally available per Anthropic, checked 2026-10-16) | `/review`; `@codex review` on GitHub |
| **Checked against** | Secondary sources, 2026-09-26; plans and the Devin CLI, 2026-10-12 | cursor.com docs, 2026-08-28; default model, `agent -p` and instruction files, 2026-10-12 | Claude Code 2.1.283, 2026-09-26 | codex-cli 0.157.1, 2026-09-26 |

Cursor names no single default model, and its plan prices are in the [pricing analysis](/en/comparison/pricing-analysis/) (cursor.com/pricing, read 2026-10-12); check cursor.com again before you buy. The [models hub](/en/ecosystem/models/) holds current model names, prices and defaults for every tool, and the [three-tool capability comparison](/en/comparison/feature-matrix/) goes deeper on Cursor, Claude Code and Codex.

## Should you keep Devin Desktop, add an agent, or move?

Decide what you are replacing before you compare anything. The editor, the agent and the model are three separate choices.

| Your situation | What to do |
| --- | --- |
| The team works well in the editor and has no agent work outside it | Keep Devin Desktop. Re-run the bake-off below at renewal. |
| You need agents in CI, on a schedule or in scripts | Add Claude Code (`claude -p`) or Codex (`codex exec`) beside the editor. Both run headless; see [headless agents in CI](/en/ecosystem/agent-tools/headless-agents-ci/). |
| Your best results come from Cognition's SWE-2 model | Keep that work in Devin Desktop until your own evals show a replacement matches it, and read its price on devin.ai/pricing before the free period ends on 2026-10-16 (checked 2026-10-12). |
| You want an IDE-first agent with documented cloud agents and a review bot | Trial [Cursor](/en/cursor-ide/), the only one of the three that is an editor. |
| You standardise one policy across several agents | Compare admin controls with [one policy for every coding agent](/en/org/managed-policy/) before you pick. |
| You are considering tools beyond these four | Start with [the coding-agent landscape](/en/comparison/agent-landscape/), which also covers Devin and the Devin CLI. |

Start every candidate on its default model: Claude Opus 5.5 in Claude Code and GPT-6.1 Sol in Codex. Tune effort before you switch model, and switch only when your evals say so.

## Can you keep Devin Desktop and add Claude Code or Codex?

Yes. Neither agent needs its own editor, so the cheapest first step is to run one in the integrated terminal on the same repository. The rules are the part that does not carry over.

**Claude Code**

    Open the integrated terminal in the repository and run `claude`. Claude Code's importer (`claude import`) reads only Codex, Gemini and Cursor configuration (checked on 2.1.296, 2026-10-12), so it does not import `.windsurf/rules/`. With `CLAUDE_CODE_NEW_INIT=1` set, `/init` does read `.devin/rules/`, `.windsurf/rules/` and `.windsurfrules` when it writes `CLAUDE.md` (Claude Code memory docs, read 2026-10-12); compare its draft with your original rules before you rely on it. Otherwise translate them by trigger as shown in [migrating from Devin Desktop](/en/teams/adopt/from-windsurf/), and start `CLAUDE.md` with `@AGENTS.md` so both release channels load the shared rules.

**Codex**

    Install the Codex IDE extension, which OpenAI's README lists for Windsurf (checked 2026-09-26), or run `codex` in the integrated terminal. Codex's `/import` is described in 0.162.1 as importing from Claude Code (checked 2026-10-12), and the 0.145.0 and 0.147.0 release notes add Cursor; neither names Windsurf, so the rules need the same translation into `AGENTS.md`. Trust the project when Codex asks: since 0.150.0, untrusted projects do not supply their `AGENTS.md`.

**Cursor**

    Cursor replaces the editor rather than sitting inside it. Move one repository first, recreate the rules through Cursor's rules settings, and re-add MCP servers there. The repository steps are in [migrating from Devin Desktop](/en/teams/adopt/from-windsurf/).

## How do you compare them on your own code?

Run the same closed issues through Devin Desktop and one or two candidates, and let tests decide. This is a short version of the site's full bake-off protocol in [the coding-agent landscape](/en/comparison/agent-landscape/); use the full protocol, with 10 to 20 tasks and three runs each, before a purchasing decision.

1. **Pick five issues** closed in the last 90 days, each fixed by one merged pull request: two bugs, two small features and one refactor.

2. **Write held-out acceptance tests** from each merged fix and keep them outside the agents' worktrees, so no agent can read or edit them. See [protecting the test oracle](/en/workflows/test/protect-the-oracle/).

3. **Start each run from the fix's parent commit in its own worktree**, on each tool's default model, with the same rules and the same MCP servers. Create the worktree with Git so every tool starts from the same commit, whatever its own worktree option would pick as a base:

   ```bash
   # Terminal: one worktree per tool, branched from the commit before the merged fix
   git worktree add -b bakeoff-claude-4312 ../bakeoff-claude-4312 <fix-sha>^
   cd ../bakeoff-claude-4312
   ```

   Replace `claude` with the tool's name (`codex`, `cursor`, `devin`), `4312` with the issue number and `<fix-sha>` with the merge commit of the fix. Then run `claude` or `codex` in that directory, or open the folder in Cursor or Devin Desktop and start its agent there.

4. **Paste the same task prompt** (the first prompt below) into every tool, and record interventions and elapsed minutes.

5. **Run the held-out tests after each agent has finished.** Copy them into the worktree, run them with your test command, and record pass or fail in the scorecard before any review agent starts:

   ```bash
   # Terminal: example for a Vitest project; use your own test runner
   mkdir -p src/__heldout__
   cp ../heldout/4312.test.ts src/__heldout__/
   npx vitest run src/__heldout__/4312.test.ts
   ```

6. **Score each branch with the remaining gates, then with the review prompt**, and fill in the scorecard from the landscape page. A human reviews only the branches that passed.

**Copy-paste prompt: the same task in every tool**

```text
Read issue #4312 with `gh issue view 4312`. Before editing, restate the
acceptance criteria as a numbered list and name the command that proves each
one. Implement the smallest change that meets them, following the rules in
AGENTS.md (or CLAUDE.md). Run the type check, the linter and the full test
suite; if anything fails, fix the cause, not the test. Do not modify or delete
existing tests. Finish with a table: criterion, test or command that proves it,
result. List every file you changed and anything you could not verify.
```

Replace `4312` with each issue number. The prompt works unchanged in Devin Desktop, Cursor, Claude Code and Codex, which is the point: a difference in the result is a difference in the tool.

**Copy-paste prompt: what ties this repository to Devin Desktop**

```text
Inventory everything in this repository that only Devin Desktop or Windsurf
reads: .windsurf/ and .devin/ directories, rule files and their `trigger`
frontmatter, workflow files, editor settings and any MCP configuration. For
each item, say whether Claude Code, Codex or Cursor would read it as-is,
and what it would have to become (AGENTS.md, CLAUDE.md, a path-scoped rule,
a skill or an MCP entry). Do not change any files. Output a table and a total
count per target, so I can estimate the switching cost.
```

**Copy-paste prompt: review a bake-off branch against its criteria**

```text
You are reviewing, not fixing. Compare branch bakeoff-<tool>-4312 with its base
commit <fix-sha>^ using `git diff`. The held-out tests in <path> have already
been run: <result>. For each acceptance criterion in issue #4312, find the test
that proves it and run it; report pass, fail or untested. Then list blocking
findings only: behaviour the issue did not ask for, weakened or deleted tests,
missing error handling on changed paths, and security-sensitive changes (auth,
secrets, migrations). Give each finding a file and line. End with ACCEPT or
REJECT and one sentence of reasoning.
```

Replace `<tool>`, `4312`, `<fix-sha>`, `<path>` and `<result>` before you paste it. Run the review prompt in a different tool from the one that wrote the branch, so an agent never grades its own work.

## How do you verify the result without reading every line?

The bake-off decides on evidence, and the same gates carry over to daily work whichever tool wins.

- **Held-out acceptance tests** decide whether a branch solved the issue. The agent that writes the fix never sees them: they are copied into the worktree only after it finishes (step 5).
- **Required CI checks**: type check, lint and tests block the merge whatever tool or editor wrote the code.
- **A review agent** runs the third prompt and reports only blocking findings, each tied to a file and line.
- **An evidence bundle in each pull request** maps every criterion to its proof, so the reviewer checks the mapping, not the diff. See [the evidence bundle](/en/workflows/ship/evidence-bundle/).
- **Human sign-off** stays with the engineer who delegated the task, who reads the diff only for auth, migrations, billing and public API changes. [Reviewing agent pull requests](/en/workflows/ship/agent-pr-review/) has the checklist.
- **The decision owner** (the tech lead for one team, the CTO for a company standard) signs off the scorecard, not the anecdotes.

## What goes wrong when teams compare against Devin Desktop?

**The comparison uses a Windsurf-era table.** Cascade, a $12 plan and "No" in every extensibility cell come from a product that no longer exists under that name. Recovery: date every cell, re-check the vendor's pages, and mark anything unchecked as "not verified" rather than "no".

**The team compares models, not tools.** SWE-2 against Opus 5.5 tells you about two models, not about two workflows. Recovery: run each tool on its default model and record the model in the scorecard; add a shared-model run where both tools offer one.

**The rules never loaded in the new agent.** Claude Code and Codex do not load `.windsurf/rules/` as instructions (Claude Code 2.1.283, codex-cli 0.157.1), so the trial runs without your conventions and looks worse than it is. Recovery: translate the rules first, then ask each agent to quote your first project rule before the task starts.

**Claude Code behaves differently across the team.** The Opus 5.5 default and the `AGENTS.md` fallback are on both release channels (`stable` is v2.1.292 on 2026-10-17), but a feature from v2.1.293 or later is on `latest` only. Recovery: pin one channel for the bake-off and note it in the scorecard.

**Codex skips `AGENTS.md` in a fresh clone.** Since 0.150.0, untrusted projects do not supply project-level instructions. Recovery: trust the project when prompted, then rerun the rule-quoting check.

**A trial agent got production access.** Connecting a cloud agent to the main repository with deploy secrets turns a trial into a risk. Recovery: run the bake-off on a fork or test repository with read-only tokens; see [permissions and sandboxing](/en/workflows/harness/permissions-and-sandboxing/).

## Where to go next

- [Migrating from Devin Desktop (formerly Windsurf)](/en/teams/adopt/from-windsurf/) — Translate .windsurf/rules by trigger, turn workflows into skills and prove the rules apply.
- [The coding-agent landscape beyond the big three](/en/comparison/agent-landscape/) — Devin, Kiro, Copilot and others, plus the full bake-off protocol and scorecard.
- [Plan prices for Claude Code, Codex, Cursor and Copilot](/en/comparison/pricing-analysis/) — What each plan includes and how to price a team from its own invoices.
- [Cursor vs Claude Code](/en/comparison/cursor-vs-claude-code/) — The editor-first and terminal-first agents compared workflow by workflow.
