Cursor vs Windsurf (now Devin Desktop): security compared

Windsurf is now Devin Desktop: Cognition renamed it on 2 June 2026, with the same editor and plans. Against Cursor, the security picture is close. Both ask before shell commands by default, both offer an OS sandbox and ignore files, and both review your changes. Cursor adds pull request security review and hosted apps with publish checks. Neither one tests the app you deploy.

The team behind Keybrum's attacksUpdated 11 min read

In short

  • Windsurf belongs to Cognition, the maker of Devin. Since 2 June 2026 the editor is called Devin Desktop, and windsurf.com redirects to Devin's site. Plans, settings and Windsurf rules carried over.
  • Devin Desktop's local agent, Devin Local, auto-approves edits inside the workspace and asks before shell commands, web fetches and MCP tools. Cursor asks before terminal commands by default too.
  • Cursor's sandbox runs on macOS and Linux and is part of its Auto-review mode. Devin Desktop's sandbox is optional, and its docs say it is not supported on Windows.
  • Both editors have public CVEs about prompt injection reaching their MCP configuration. Update, and read rules and MCP files you did not write.
  • Reviews in both editors read code. A table left open in Supabase, a key in your bundle or a missing owner check on a route is found by testing the deployed app.
On this page

First, who ships Windsurf today

If you compare Cursor and Windsurf in late 2026, you are comparing Cursor and Devin Desktop. Cognition, the company behind the Devin agent, signed the agreement to take over Windsurf in July 2025. On 2 June 2026 it renamed the editor. Its FAQ says: "Devin Desktop is the new name for Windsurf. It's the same IDE, same editor, and has the same features, but unified under the Devin brand." Plans and prices did not change, settings were ported, and the Windsurf documentation now lives on Devin's docs site.

Two things did change for security. New conversations no longer use Cascade, Windsurf's original agent: they start with Devin Local, which shares its engine with the Devin CLI. And the old auto-execution levels for terminal commands gave way to a permission system with allow, ask and deny rules. Articles written before June 2026 describe a product that works differently now.

This page compares what each editor's own documentation said on 13 November 2026 about approvals, sandboxing, secrets and review. It does not judge which one writes better code. For Cursor alone, see Cursor app security.

Cursor vs Windsurf: security features side by side

QuestionCursorWindsurf, now Devin Desktop
VendorCursorCognition
Local agentAgentDevin Local (Cascade is legacy and no longer starts conversations)
File editsWorkspace files without approval, except configuration filesAuto-approved inside the workspace in Code mode, the default
Shell commandsNeed approval by default. Run Modes: Auto-review, Allowlist, Run EverythingPrompt unless an allow rule covers them. Modes: Code, Smart, Ask, Plan, Bypass Permissions
Automatic judge of risky actionsAuto-review classifier, on Cursor's backendSmart mode, a fast model, rolling out gradually
OS sandboxmacOS (Seatbelt) and Linux (Landlock, seccomp). Network blocked by default, then opened to a default listOptional. Linux needs bubblewrap and socat. Not supported on Windows. Network filtering marked unstable
Reach outside the projectReads outside the workspace allowed by default (Read Access: System)Devin Local reads and edits only inside the workspace by default
Ignore files.env* and .gitignore entries by default, plus .cursorignore. Terminal and MCP tools can still read them.gitignore entries cannot be edited by the agent; .devinignore blocks viewing, editing and creating
MCP toolsEvery connection and every tool call needs approval unless allowlistedPrompt before any MCP tool call by default
Rules files.cursor/rules/*.mdc, AGENTS.md.devin/rules/, legacy .windsurf/rules/ and .windsurfrules, AGENTS.md. Can import .cursor/rules
Review of your changesBugbot and Security Review on pull requests, /review-security on a branchQuick Review: a second agent reviews local changes
HostingApps, with a Postgres database and publish checksPreviews of your local app. Its current docs describe no managed hosting
Sources: cursor.com/docs and docs.devin.ai, read on 13 November 2026.

What the agent can do on your machine

Cursor

Cursor's agent reads and searches without asking, edits workspace files, and needs approval for terminal commands, MCP connections and configuration files. Run Modes change how much runs alone. Auto-review runs allowlisted calls at once, puts other shell commands in the sandbox, and sends what cannot be sandboxed to a classifier. Allowlist runs only what you listed. Run Everything has no sandbox and no classifier. Cursor says Auto-review is "not a security boundary".

The sandbox blocks the network, then opens it to a built-in list of package registries and git hosts. It protects .git/config, .git/hooks, .vscode and .cursorignore. By default the agent can read files outside your project without approval; set Read Access to Workspace to make it ask. Workspace Trust is off by default.

Windsurf, now Devin Desktop

Devin Local has five modes. Code, the default, auto-approves edits inside the workspace; shell commands, web fetches and MCP tools prompt unless an allow rule covers them. Smart adds a fast model that approves actions it judges safe, while package installs, mutating git, rm, sudo and sensitive files always prompt. Ask and Plan are read-only. Bypass Permissions approves every tool call, except what an organization's policy forbids.

Rules are the strong part of this design. Deny, ask and allow rules can be scoped to file reads, file writes, commands, HTTP fetches and MCP tools, at project, user or organization level, and deny wins. A Write(.env*) entry in the deny list, or a Read rule for your key files, holds in every mode. The sandbox is opt-in: when enabled, writable paths come from your permission scopes, and paths under a Read deny rule are hidden from commands. It refuses to start if the sandbox tools are missing, instead of running without them. Cognition's docs say it is not supported on Windows, and mark network filtering as unstable.

Secrets, ignore files and rules you did not write

Both editors keep some files away from the agent, with limits each vendor states. Cursor ignores .env* files and everything in .gitignore by default, and .cursorignore adds patterns. Its docs add that the terminal and MCP tools cannot be blocked from reading those files, and that complete protection is not promised. Devin Desktop does not index files matched by .gitignore, and the agent cannot edit them unless you turn on Gitignore access, which is off by default. A .devinignore file goes further: matched paths cannot be viewed, edited or created.

Since most projects list .env in .gitignore, both editors start in a reasonable place. Neither makes a production key safe on a machine where an agent runs shell commands. Use test keys locally.

Rules files are the other shared risk. Devin Desktop reads .windsurfrules, .windsurf/rules/, .devin/rules/ and AGENTS.md, and can import Cursor's .mdc rules. Cursor reads .cursor/rules and AGENTS.md. A rules file is a prompt that loads without you typing it. In 2025, Pillar Security showed that invisible Unicode characters in such a file could steer Cursor's agent. Read any rules file that came with a template or a cloned repository, in either editor.

Review tools: what each editor reads

Cursor has the wider set. Bugbot reviews every pull request for bugs and security issues. Security Review checks pull requests for vulnerabilities, and /review-security runs the same review on your branch before you push, in Cursor 3.7 and later. Vulnerability Remediation scans merged code and patches confirmed findings. One trap: Bugbot's GitHub check ends as neutral when it finds issues, unless you set it to fail.

Devin Desktop has Quick Review: after Devin Local changes files, a second agent reviews the diff for correctness, style and potential issues, and shows feedback in the editor. Its SWE-check model costs nothing on paid plans. It is a general code review, and Cognition's page does not present it as a security scanner. If you want a security pass in Devin Desktop, ask for one explicitly, or run a scanner in CI.

Cursor also hosts apps. With Apps, on paid plans with cloud agents, a publish stops if a file holds an API key or a credential file, .env files are left out and source maps are removed. That protection applies only to apps Cursor hosts. Deploy to Vercel or Netlify from either editor and those checks are yours to reproduce.

What neither of them checks: the app you deploy

Everything above happens in the editor or on a pull request. Your users meet the app somewhere else, and three kinds of leak are decided there.

On the live appHow it goes wrongWhy the editor cannot see it
Database policiesA Supabase table without row level security, or Firebase rules open to any signed-in userThe policy lives in the provider. A change made in a dashboard touches no file
Keys in the bundleA secret stored under a NEXT_PUBLIC_ or VITE_ name ships to every visitorThe value sits in your host's environment settings
Per-user accessA route returns any record to any signed-in user who knows its idOnly two real accounts on the running app show it
Open routesAn AI route answers without a session; a Stripe webhook accepts unsigned eventsThe code can look right and one route can still skip the check

None of this depends on the editor. CVE-2025-48757 was assigned after 170 of 1,645 Lovable apps tested had missing or weak row level security, and a migration written in Cursor or Devin Desktop can create the same open table. The vibe coding security risks guide lists the patterns, and the Firebase rules guide covers the Firebase side.

A self-check you can run today

  1. 1

    Scan rules files for hidden characters

    Run the first command below in your repository. It prints any line with invisible Unicode in the rules files both editors load. It should print nothing.

  2. 2

    List tables without row level security

    Run the SQL below in the Supabase SQL editor. On Firebase, paste your rules into the Firebase rules checker instead.

  3. 3

    Search the build for secret keys

    Build, then run the grep below. The frontend API key guide says which keys are public by design.

  4. 4

    Try the two-account test

    Create accounts A and B. As A, create a record and copy its id from the network tab. As B, request that id. Then request it signed out. B should get a 404 and the signed-out call a 401. See the IDOR guide if not.

  5. 5

    Check headers and leftovers

    Run the security headers checker on your address, and confirm /.env returns nothing useful with the last command.

bash
LC_ALL=C.UTF-8 grep -rnP '[\x{200B}-\x{200F}\x{202A}-\x{202E}\x{2060}-\x{2064}\x{FEFF}\x{E0000}-\x{E007F}]' \
  .cursor .devin .windsurf AGENTS.md .windsurfrules .cursorrules 2>/dev/null

npm run build
grep -rlE "sk_live_|rk_live_|sk-proj-|sk-ant-|sb_secret_|PRIVATE KEY-----" .next/static dist build 2>/dev/null

# Your own app only. Expect a 404 page, never file contents.
curl -s https://your-app.example/.env | head -n 5
sql
select schemaname, tablename
from pg_tables
where schemaname = 'public'
  and rowsecurity = false
order by tablename;

Settings to change in each editor

  • Cursor: stay on Auto-review or Allowlist. Set Read Access to Workspace.
  • Cursor: turn on Workspace Trust for repositories you did not write, and make the Bugbot check fail on unresolved issues if your plan allows it.
  • Devin Desktop: stay in Code mode for daily work, and keep Bypass Permissions for throwaway environments.
  • Devin Desktop: add deny rules for secrets, for example Write(.env*) and a Read rule for key files, and leave Gitignore access off.
  • Devin Desktop: on macOS or Linux, try the sandbox for unattended runs. On Windows it is not available, so keep prompts on.
  • Both: approve MCP servers one by one, and re-read a project's MCP configuration after pulling changes.
  • Both: update the editor, and test the live app after every deploy.

Where Keybrum fits, and where it does not

Keybrum does not test editors. It has no view of Cursor's Run Modes, Devin Desktop's permissions or anything on your machine, and it does not replace Bugbot or Quick Review. If your worry is what the agent can do to your laptop, the settings above are where to act.

Keybrum tests what you shipped, on apps whose owner proved ownership. It reads Supabase tables with the public key, signed out and then as a new account, and does the same with Firestore collections and Storage. It calls the API routes your JavaScript names with no session, and runs the two-account test with a marked record. It checks whether keys in the bundle work, posts a short prompt to AI routes, sends one unsigned event to your Stripe webhook, and looks for a served .env, a .git folder, source maps and missing security headers. Each finding comes with the request that worked and a fix written for a coding agent, readable through Keybrum's MCP server (setup).

A one-time report is €49 for one app. Plans start at €29 a month excluding VAT for 5 apps; the Team plan at €99 covers 25 apps and puts your brand on reports, which suits agencies that deliver apps built in either editor.

Questions

Who owns Windsurf now?

Cognition, the company that makes the Devin coding agent. It signed the agreement to take over Windsurf in July 2025 and renamed the editor Devin Desktop on 2 June 2026. Cognition's FAQ says plans and pricing did not change and existing settings were ported.

Is Windsurf the same as Devin Desktop?

Yes. Cognition describes Devin Desktop as the new name for Windsurf, with the same IDE and features. What changed is the default agent: new conversations use Devin Local, and Cascade, the original Windsurf agent, is now legacy.

Is Windsurf safer than Cursor?

The documentation does not support a clear ranking. Devin Desktop keeps its local agent inside the workspace by default and has fine-grained deny rules; Cursor has a sandbox on by default in Auto-review, pull request security review and publish checks for hosted apps. Both have public CVEs. Your settings and your review habits weigh more than the choice.

Do my .windsurfrules files still work?

Yes. Devin Desktop still reads .windsurfrules and .windsurf/rules/, and adds .devin/rules/, which takes precedence. It also reads AGENTS.md and can import Cursor's .mdc rules. Treat every rules file as a prompt: read the ones you did not write.

Does Cursor or Windsurf scan my app for vulnerabilities?

Cursor reviews code: Bugbot and Security Review on pull requests, and /review-security on a branch. Devin Desktop's Quick Review is a general review of local changes. Neither sends requests to your deployed app, so database policies, keys in the bundle and access between accounts are not covered.

Can the agent read my .env file?

Both editors ignore files listed in .gitignore by default, and Cursor also ignores .env*. Cursor says its terminal and MCP tools can still read ignored files. In Devin Desktop, a .devinignore entry or a Read deny rule is the stronger control. Keep production keys off the machine either way.

Sources

  1. 1.Devin Desktop FAQ, Cognition
  2. 2.One Year of Building Together, Cognition
  3. 3.Devin Local Modes, Cognition
  4. 4.Devin Local Permissions, Cognition
  5. 5.Devin Local overview: sandboxing and enterprise controls, Cognition
  6. 6.Sandbox, Cognition
  7. 7.Devin Desktop .devinignore, Cognition
  8. 8.Quick Review, Cognition
  9. 9.Cascade (legacy), Cognition
  10. 10.Agent security, Cursor
  11. 11.Run Modes, Cursor
  12. 12.Ignore files, Cursor
  13. 13.Security Agents, Cursor
  14. 14.Bugbot, Cursor
  15. 15.Apps, Cursor
  16. 16.CVE-2025-54135, CVE Program
  17. 17.CVE-2025-54136, CVE Program
  18. 18.CVE-2026-30615, CVE Program
  19. 19.CVE-2025-62353, CVE Program
  20. 20.New Vulnerability in GitHub Copilot and Cursor: How Hackers Can Weaponize Code Agents, Pillar Security
  21. 21.CVE-2025-48757, NVD

Your app is public. So are its mistakes.

Check what any attacker can already see in it, free, in ten seconds. The full attack, with proof and fixes: €49 once, or €29 a month on a plan.

or continue with Google or GitHub