Claude Code vs Cursor: Which Fits the Way You Work

Claude Code and Cursor do the same core job: you describe a change, and the agent reads code, edits files, runs commands and checks the result. The difference is where the work starts. Claude Code is Anthropic’s coding agent. It began in the terminal and now runs in editors, a desktop app and the browser, with one engine and one configuration behind all of them. Cursor is an AI code editor with its agent built into the editor, plus a command-line agent and cloud agents. Choose Claude Code if your work starts from a prompt and you want the same agent in a terminal, a script and CI. Choose Cursor if your work starts from an open file and you want the agent, the diff and the editor in one window. Neither is better in general, and plenty of people use both.

Where each one runs

According to Anthropic’s overview↗ (opens in a new tab), Claude Code runs in the terminal, in VS Code and JetBrains extensions, in a desktop app and on the web, and each surface connects to the same engine, so your CLAUDE.md files, settings and MCP servers work across all of them. The terminal is still the most complete surface: claude -p runs it from a script or a CI job with no one watching. Which surface to use day to day is covered in Claude Code desktop vs CLI vs VS Code.

Cursor is an editor first. The agent sits in a chat panel beside your files, with Agent, Plan and Ask modes. Cursor also ships a command-line agent, started with agent, which uses the same rules system as the editor and picks up the same MCP configuration, and cloud agents that run away from your machine. So the choice is less about capability than about which window you want to live in.

How each takes a task

• Claude Code: you type the task at a prompt, or pass it on the command line with claude "fix the failing auth tests". It goes and finds the files it needs, so it does not matter what you have open. You can queue a follow-up message while it works.
• Cursor: you type the task in the chat panel, usually with the relevant file already open, and you can @-mention files and rules to steer what it reads. The diff appears in the editor as it works, so you watch changes land in the code rather than in a transcript.

The same task wording works for both. What goes into a good one is in how to write a task for an AI agent.

Plan modes

• Claude Code: plan mode is one of its permission modes. Press Shift+Tab until it shows, or start with claude --permission-mode plan. It reads the code and proposes an approach, and nothing is edited until you accept. The detail is in Claude Code plan mode.
• Cursor: press Shift+Tab in the chat input to rotate to Plan Mode, or pick it from the mode menu. The agent asks clarifying questions, researches the codebase and writes a plan you review before any code changes. Plans are saved in your home directory by default, and Save to workspace moves one into the project.

The shortcut is the same; the difference is what is left afterwards. Cursor’s plan is a Markdown file you can keep in the repository. Claude Code’s plan is presented in the session for you to accept or change; if you want it kept, ask for it to be written somewhere a colleague will find it.

Instruction files: CLAUDE.md and rules

Claude Code reads CLAUDE.md at the start of every session, from your project and the directories above it, and .claude/rules/ holds rules scoped to particular files. Its memory documentation↗ (opens in a new tab) says it reads AGENTS.md only when there is no CLAUDE.md or CLAUDE.local.md in the working directory or above it; with both present it reads CLAUDE.md only, unless CLAUDE.md imports AGENTS.md or you change the Project instructions setting.

Cursor keeps project rules as .mdc files in .cursor/rules, each applied always, when the agent judges it relevant, to matching files, or when you @-mention it. It also reads AGENTS.md at the root and in subdirectories. And Cursor’s rules help page↗ (opens in a new tab) says it reads CLAUDE.md the same way it reads AGENTS.md, and applies it to every conversation regardless of any alwaysApply setting.

That last point matters if you use both. Whatever you write in CLAUDE.md for Claude Code reaches every Cursor chat too. The tidy arrangement is shared rules in AGENTS.md, and a short CLAUDE.md that imports it and adds only what is specific to Claude Code:

# AGENTS.md (Cursor reads it directly; Claude Code through the import)
## Build and test
- pnpm install, then pnpm test before any commit.
- Never edit files under src/generated/.

# CLAUDE.md
@AGENTS.md
## Claude Code only
- Use plan mode for any change touching more than three files.

Rule types in Cursor are in Cursor rules for AI projects, and the full map of which tool reads which file is AI context files compared.

Approvals and undo

Claude Code sets approval with a permission mode, switched with Shift+Tab. Manual asks before most edits, commands and network access; acceptEdits lets file edits through; plan reads only; auto has a second model review actions instead of you; dontAsk suits locked-down CI; bypassPermissions is for isolated containers only. Allow and deny rules sit on top, and deny rules hold in every mode. For undo, every prompt creates a checkpoint, and /rewind (or Esc twice) restores the code, the conversation or both. The checkpointing documentation↗ (opens in a new tab) is clear about the limit: files changed by Bash commands such as rm or mv are not tracked, and checkpoints are no replacement for git. How far to loosen approvals is in Claude Code auto-approve.

Cursor calls these run modes. Its run modes page↗ (opens in a new tab) lists Auto-review, where allowlisted calls run at once, other shell commands run in the sandbox where possible and a classifier reviews riskier calls; Allowlist, where only what you listed runs without approval; and Run Everything, with no review at all. MCP tool calls go through the same flow. Checkpoints are made automatically before significant changes; restoring one reverts files, not the conversation, and they are stored locally, separate from Git.

The shared limit: both rewind files, not the world. A migration that ran, a message that was sent, or a task moved on a board through MCP stays done. Keep approvals strictest for those.

Background and cloud agents

• Claude Code: sessions on the web at claude.ai/code run in the cloud against your repository and keep going after you close the laptop; claude --teleport pulls one into your terminal. It also answers @claude in GitHub issues and pull requests through GitHub Actions, and in Slack. Running sessions in the background locally is covered in Claude Code background tasks.
• Cursor: cloud agents↗ (opens in a new tab) run in isolated virtual machines with full development environments. You start them from Cursor on the web, the desktop app, the iOS app, Slack, Linear, the API, or @cursor on a GitHub issue or pull request or a Bitbucket pull request. They clone from GitHub, GitLab, Bitbucket Cloud or Azure DevOps, work on a separate branch and push it.

MCP

Both are MCP clients for local and remote servers. In Claude Code, claude mcp add registers a server for you in the current project by default; --scope project writes it to a .mcp.json you commit, and --scope user makes it available in every project. Cursor reads .cursor/mcp.json in the project or ~/.cursor/mcp.json for every project, over stdio, SSE or Streamable HTTP, and its command-line agent uses the same file.

# Claude Code, shared with the team through .mcp.json
claude mcp add --transport http --scope project fenbs https://fenbs.ai/api/mcp

// Cursor: .cursor/mcp.json
{ "mcpServers": { "fenbs": { "url": "https://fenbs.ai/api/mcp" } } }

Team use

• Shared setup in the repository: Claude Code keeps CLAUDE.md, .mcp.json, subagents in .claude/agents and skills in the project. Cursor keeps .cursor/rules and .cursor/mcp.json, and on team plans adds rules managed from a dashboard.
• Pull request review: Claude Code has a managed Code Review that posts findings as inline comments by severity and never approves or blocks a pull request. Cursor has Bugbot, which reviews pull requests automatically or when someone comments bugbot run, and reads .cursor/BUGBOT.md. How to fit either into review is in AI agents for PR review.
• Billing: the two are billed differently and both change their plans often. Check each vendor’s current plans rather than any comparison post, this one included.

Who each suits

• You live in the terminal, script your tools, or want the same agent in CI: Claude Code.
• You live in the editor and want to see each change land in the file you are reading: Cursor.
• You are new to coding agents: start where you already are. An editor is a gentler first step than a terminal, and that is true of Cursor and of Claude Code’s desktop app and VS Code extension alike; Claude Code for beginners walks through a first session.
• You want to start long tasks from Slack or a tracker: both can. Cursor’s cloud agents start from Slack and Linear; Claude Code starts from Slack, the web and the mobile app.
• Your code is not on GitHub: Cursor’s cloud agents clone from GitLab, Bitbucket and Azure DevOps. Claude Code runs in your terminal on any repository, and has a GitLab CI/CD integration.

Using both together

They are not exclusive. The Claude Code extension installs in Cursor as it does in VS Code, so you can keep Cursor as your editor and run Claude Code in a panel beside it. Keep one AGENTS.md for the shared rules, point both MCP files at the same servers, and do not let two agents edit the same branch at the same time: give each its own branch or worktree, and one task each.

One list of work, whichever agent picks it up

Each tool keeps its own record: a Claude Code transcript, a Cursor chat, a cloud agent run on one person’s account. None of them is where your colleagues look. Put the work on a board both can reach. On fenbs, both connect to the same MCP address with a browser sign-in; you tick what each may do, and every change is recorded in History under the assistant’s name, on your behalf. Tasks sit in To Do, Next Up, In Progress and Completed, each with a problem, a plan and how it was tested. One line in AGENTS.md does the rest: move the task to In Progress when you start, comment what changed and how it was checked when you stop.