Is there a free alternative to Cursor?

VS Code costs nothing, and Zed is free and open source; Zed can use your own API keys or a local model. You still pay whichever model provider or agent you connect unless you run a local model. Several vendors on this page also offer a free tier with limits, so check their current plans.

What happened to Windsurf?

Cognition renamed Windsurf to Devin Desktop on June 2, 2026. On September 8, 2026 it removed Cascade, the original agent, and Devin Local became the only built-in agent. Old Windsurf rules folders are still read.

Which Cursor alternatives can run Claude Code?

VS Code offers an Anthropic Claude harness, Zed and JetBrains AI Assistant can host Claude as an external agent over the Agent Client Protocol, and Devin Desktop can run it in its Agent Command Center. In each case the Claude agent uses its own sign-in and billing.

Do my Cursor rules work in other editors?

Not directly. The .mdc files in .cursor/rules are Cursor’s format. Put shared guidance in AGENTS.md, which all of these editors read, and keep only Cursor-specific details in .cursor/rules.

Cursor Alternatives: AI Editors Compared

The editors people pick instead of Cursor, sorted by the reason you would switch: staying in VS Code, a faster native editor, a JetBrains IDE, a spec-first workflow, or a command center for many agents. What each one is today, and what to carry over when you move.

September 29, 20267 min read

The right Cursor alternative depends on what you want to keep. If you want to stay in plain VS Code, GitHub Copilot’s agent now runs there with a choice of harnesses. If you want an editor built around an agent manager, Devin Desktop (the IDE formerly called Windsurf) and Google Antigravity are designed for that. If you want a fast native editor that hosts other companies’ agents, Zed does it through the Agent Client Protocol. If you live in IntelliJ or PyCharm, JetBrains AI Assistant and Junie keep you there. If you want requirements and a design approved before any code, Kiro builds that in. Whichever you choose, your AGENTS.md, your MCP servers and your task list move with you almost unchanged.

This page is a map by fit, one short paragraph per editor, each linking to a longer comparison where one exists. No prices: plans change often, so check each vendor’s current page. Terminal agents such as Claude Code, Codex CLI and Gemini CLI are covered separately in Claude Code alternatives.

Why people look beyond Cursor

Editor habits: some teams are standardized on VS Code or a JetBrains IDE and do not want a fork of either.
Account and billing: the agent has to fit how the company already pays, whether that is GitHub, Google Cloud, AWS or a JetBrains license.
Agent choice: a few editors now host several companies’ agents side by side instead of shipping one.
Workflow shape: a spec-first flow, a board of parallel agents and a chat beside the file are different ways to work, not better or worse ones.
Performance and platform: a native editor, or one that runs where your team already works, can matter more than any single feature.

Stay in VS Code

VS Code with GitHub Copilot

If your team came to Cursor from VS Code, plain VS Code with Copilot is the shortest move back. You give the agent a task in the Chat view or the Agents window, pick Agent or Plan, and review the diff in the file. The notable change is choice of engine: VS Code’s page on agent harnesses (opens in a new tab) lists Local, GitHub Copilot, Anthropic Claude and OpenAI Codex harnesses, plus a Cloud target that runs a cloud agent remotely. It reads AGENTS.md and .github/copilot-instructions.md, and MCP servers go in .vscode/mcp.json. Suits teams whose code, reviews and permissions already live in GitHub. The agent-to-agent comparison is in GitHub Copilot agent vs Cursor agent.

An editor built around agents

Devin Desktop, formerly Windsurf

Windsurf no longer ships under that name. Cognition renamed it Devin Desktop on June 2, 2026, and the Devin Desktop changelog (opens in a new tab) entry for September 8, 2026 says Cascade, its original agent, has been removed and Devin Local is now the only built-in agent. The IDE opens on the Agent Command Center, a Kanban view of local and cloud agent sessions, and it can host third-party agents over the Agent Client Protocol. It reads .devin/rules/, the old .windsurf/rules/, and AGENTS.md. Suits teams that want the Devin cloud agent and a local editor under one account. See Windsurf vs Claude Code.

Google Antigravity

Antigravity began as an IDE with an Agent Manager beside the editor. Google’s Antigravity 2.0 overview (opens in a new tab) now describes a standalone desktop app for launching and watching many agents, which works independently of an IDE, alongside a CLI, the Antigravity IDE and editor extensions. You review agents’ work as artifacts: implementation plans, walkthroughs, screenshots and browser recordings. Its model picker offers Gemini models and some non-Google models. Suits people who want to supervise several agents and review deliverables rather than watch each edit. See Antigravity vs Claude Code.

A fast editor that hosts other agents

Zed

Zed is a high-performance editor for macOS, Linux and Windows, open source under GPL-3.0. Its own Zed Agent runs in the Agent Panel on models you configure: Zed-hosted models, your own API keys, some existing subscriptions, gateways or local models. Its difference from Cursor is that it also hosts other agents. Zed’s External Agents page (opens in a new tab) lists Claude, Codex, OpenCode, Copilot, Cursor and Pi among the agents you install from the ACP Registry, with Gemini CLI covered too, each keeping its own sign-in and billing. Suits people who want a quick editor and freedom over which agent does the work. The full picture is in Zed’s AI agent.

Stay in a JetBrains IDE

JetBrains AI Assistant and Junie

JetBrains AI Assistant is the plugin that brings AI Chat, completion and coding agents into IntelliJ IDEA, PyCharm, WebStorm, Rider and the rest. Its activation page (opens in a new tab) lists four routes: a JetBrains AI subscription, an integrated agent (Junie, Claude Agent, Codex or GitHub Copilot), any ACP-compatible agent, or your own API key for a third-party provider. Junie, JetBrains’ own agent, uses the IDE’s inspections, refactorings and test runner, and also ships as a CLI. Suits teams that would rather keep the IDE than move to a VS Code fork. See Junie vs Claude Code and Claude Code in JetBrains.

Specs before code

Kiro

Kiro, from AWS, is built around specs: for a feature it writes requirements, a design and a task list, you approve each, and then it works through the tasks. The same agent harness runs in the Kiro IDE, the Kiro CLI, on the web, on iOS and in editors that speak ACP. Standing instructions go in steering files under .kiro/steering/, and it reads AGENTS.md too. AWS now points users of the Amazon Q Developer IDE plugins to Kiro. Suits teams that want the same ceremony on every feature. See what Kiro is and Kiro vs Claude Code.

Or skip the editor: terminal agents

If what you liked in Cursor was the agent rather than the editor, a terminal agent may suit you better: Claude Code, Codex CLI, Gemini CLI, OpenCode and others work beside any editor, including the one you already have. Cursor has its own terminal agent too, covered in Cursor CLI. The terminal options are compared in Claude Code alternatives, and Cursor against Anthropic’s agent in Claude Code vs Cursor.

What to carry over from Cursor

Switching is cheap when your instructions and connections live in files. Three things travel; a few do not.

AGENTS.md: the AGENTS.md format (opens in a new tab) is a plain Markdown file for build commands, conventions and no-go areas. Cursor reads it, and so does every editor on this page. Move anything general out of .cursor/rules into AGENTS.md before you switch.
Rules files: .mdc files in .cursor/rules are Cursor’s own format. Devin Desktop can import .cursor/rules into its own folder. Zed uses the first project instruction file it finds and checks a root .cursorrules before AGENTS.md, so delete a stale .cursorrules when you move. Treat tool-specific rules as a thin layer on top of AGENTS.md. Examples are in Cursor rules examples, and which tool reads what is in AI context files compared.
MCP servers: the server URL and its sign-in stay the same; only the config file changes. Cursor keeps them in .cursor/mcp.json; VS Code uses .vscode/mcp.json with a servers key; Zed uses context_servers in its settings; Kiro uses .kiro/settings/mcp.json. The differences are listed in MCP clients compared.
What does not travel: checkpoints, run modes, chat history and plans saved in your home directory. Relearn each editor’s approvals before you let its agent run commands unattended.

One shared file, one thin pointer per tool

AGENTS.md                  # build, test, conventions, no-go areas
.cursor/rules/cursor.mdc   # only what is specific to Cursor
.kiro/steering/kiro.md     # only what is specific to Kiro
CLAUDE.md                  # @AGENTS.md, plus Claude-only notes

Keep the work list outside the editor

The plan is the thing most likely to stay behind when you change editors, because it usually lives in one tool’s chat. fenbs keeps it on a board instead: each task has a note saying what and why, a plan, and a test status, in lanes To Do, Next Up, In Progress and Completed. Any editor above that speaks MCP connects to https://fenbs.ai/api/mcp with OAuth or a token you issue under Settings with a name, scopes and an optional expiry, and clients that only start local servers can use the bridge, npx -y fenbs-mcp. History records each change under the assistant’s name, so a task Cursor started and Zed finished reads as one story. fenbs is deliberately small: no sprints, due dates or epics.

Set-up pages: Cursor, GitHub Copilot, Devin Desktop and the MCP docs. For teams choosing an assistant rather than an editor, see GitHub Copilot alternatives.