Claude Code vs Cursor, an agent in the terminal or an assistant inside the editor

The comparison used to be simple. Cursor was an editor with a very good assistant in it, and Claude Code was a command you typed into a terminal. In 2026 both have grown into the other's territory: Cursor ships a CLI, Claude Code ships a desktop application and editor extensions. What remains is a genuine difference in where the work is centered and in how each product is sold. That is the part worth deciding on.

What each one is now

Cursor is a code editor, built as a fork of VS Code, with agents as the main event rather than an add-on. The agent works in three modes: full Agent access for making changes, Plan for designing an approach with clarifying questions first, and Ask for read-only exploration. Around the editor sit cloud agents that keep running after the window closes, Bugbot for agentic code review, and automations that route and approve pull requests. Cursor CLI installs with a one-line script and puts the same agent in a terminal, with agent -p for scripted runs and a handoff that pushes a conversation to a cloud agent by prefixing a message with an ampersand.

Claude Code is a coding agent that starts in the terminal. The same engine is available through a desktop application with a Code tab, and through extensions for VS Code and JetBrains editors. It has permission modes rather than editor modes, a project memory file, hooks, skills, subagents, worktree isolation for parallel sessions, and a remote control feature that lets a session running on the Mac be continued from a phone or a browser.

The shapes are mirror images. Cursor starts from the editor and reaches out to the terminal and the cloud. Claude Code starts from the terminal and reaches out to a window and an editor. Neither is a subset of the other.

Price, as published

	Cursor	Claude Code
Free tier	Hobby, limited agent requests	None for Claude Code
Individual	20 USD per month	20 USD per month with Pro, or 17 USD on annual billing
Higher tier	Pro+ and Ultra above the individual plan	Max from 100 USD per month
Team	40 USD per user per month	Team and Enterprise plans
Enterprise	Custom	Custom

Both vendors exclude tax and both change these numbers. The structural difference is at the entry: Cursor has a free tier that does real work, while Claude Code requires a paid Claude plan, with the free claude.ai plan explicitly excluded. For someone evaluating with no budget, that is not a small detail.

At the top end the shapes differ too. Cursor adds usage-based billing for some features on top of a seat price. Claude Code's higher tiers are fixed monthly amounts with larger usage allowances per session and per week. Heavy users tend to find one model or the other matches their spending pattern better, and the only way to know which is to run a normal week on each.

One vendor's models, or many

Cursor's position is model choice. Its own materials list frontier models from several vendors in the picker, including Anthropic, OpenAI, and Google models alongside Cursor's own Composer. If a new model arrives and turns out to be better at a particular kind of work, it appears as another entry in the same interface.

Claude Code runs Anthropic models. That is a constraint, and it is also the reason its behavior is consistent: the harness, the permission system, and the model are built together, and features like agent teams and dynamic workflows assume that.

Neither choice is obviously right. Model variety is worth most to people whose work spans very different tasks, or who want insulation from one vendor's pricing and availability. A tightly integrated single-vendor harness is worth most to people who care more about predictable behavior in a long session than about picking the best model per task. Enterprises often end up with both for exactly this reason.

Where the project's rules live

Both tools solved the same problem, which is that a model has no memory of the project between sessions, and both solved it with files in the repository.

Cursor uses project rules stored as .mdc files in .cursor/rules, scoped by path patterns or applied always, plus user rules for personal preferences and team rules managed from a dashboard. It also reads AGENTS.md as a plain markdown alternative.

Claude Code reads CLAUDE.md from the project, with CLAUDE.local.md for personal additions, and the same file is used by the CLI, the desktop application, and the editor extensions.

Practical consequence: a repository can carry both. Keeping the same substance in each file costs a little duplication and buys the freedom to switch tools without retraining them. Anyone maintaining a shared codebase should treat these files as documentation that happens to be read by machines, and review them in pull requests like any other source file.

Reviewing what the agent did

The two products diverge most in how changes are inspected, and this is where personal preference dominates.

In Cursor, the change appears in the editor, in the file, with the surrounding code visible. For someone who reads code all day, that is the fastest possible review surface, and the editor's own tooling for search, definitions, and version control sits right there.

Claude Code offers a spectrum. In the terminal, changes arrive as text diffs. In the desktop application, a diff view shows what changed per file and comments can be left on specific lines for the agent to address, and a review pass can be requested over the diff. Permission modes decide whether the review happens before or after the change lands: Manual asks first, Accept edits applies and lets the review happen afterwards, Plan produces an approach without touching files.

There is a subtler difference in what each one encourages. An editor invites reading each change as it appears. A terminal agent invites delegating a larger unit of work and reviewing the result as a whole. Teams that care about small reviewable increments often prefer the former, while people running several tasks in parallel tend to prefer the latter.

Running several tasks at once

Both products have an answer for parallel work, and the answers reveal their centers of gravity.

Cursor splits work between the editor and its infrastructure. Subagents take on focused pieces of an investigation and report back, while cloud agents run tasks remotely and can be picked up later on the web or a phone. The handoff is deliberate: a conversation started locally can be pushed outward mid-sentence.

Claude Code keeps parallel work on the machine by default. The desktop application manages concurrent sessions as tabs in a sidebar, and each session can run in its own Git worktree so two tasks editing the same repository do not collide. In the terminal the equivalent is one session per window plus the --worktree flag. Agent teams, where one session coordinates teammates from a shared task list, are documented as available in the CLI and not in the desktop application. Cloud sessions exist for work that should outlive the window, and remote control exists for work that should stay local while being watched from elsewhere.

The practical question is where the risk sits. Work that runs on a vendor's infrastructure survives a closed laptop but means the repository is copied there. Work that runs locally keeps the files on the Mac but stops when the machine sleeps. Choosing per task, rather than once for everything, is usually the right habit.

How much freedom the agent gets

Control over what an agent may do without asking is a category of its own, and the two products approach it from different directions.

Claude Code exposes permission modes at the session level. Manual asks before each edit or command. Accept edits applies file changes and leaves the review until afterwards. Plan produces an approach without touching files. Auto lets a classifier screen actions in the background and block risky ones instead of prompting. Bypassing permissions entirely is possible but has to be enabled deliberately, and on Team and Enterprise plans an organization policy governs it. Rules in a settings file apply across sessions, and hooks can run checks of your own before or after the agent acts.

Cursor's modes carry part of this responsibility, with Ask being read-only and Plan stopping short of changes, and its enterprise tier adds administrative controls over auto-run, browser access, and network access. For a solo user the everyday experience is similar: decide whether to inspect each step or to inspect the result. For an organization, the question becomes which product's controls map onto existing policy, and that is worth checking against the current documentation rather than a blog post, since both change often.

Running both, and what that costs

Plenty of people use both, and the tools do not conflict. Claude Code's VS Code extension runs inside Cursor, since Cursor is a VS Code fork. Cursor CLI and Claude Code can both be installed on the same Mac and pointed at the same repository.

The cost of that arrangement is two subscriptions and a split habit, not technical friction. Before paying twice, it is worth being precise about which activity is actually being improved: exploration and small edits, or long unattended runs. If both answers point at the same tool, the second subscription is doing nothing.

The problem neither tool solves

Both products assume the work lives in a repository. A lot of Mac work does not.

A real project is a repository plus a folder of client PDFs, plus an export sitting in Downloads, plus video or design files on an external drive. An editor opens a workspace. A terminal agent opens a directory. Everything outside that boundary gets fetched by hand: switch to Finder, find the file, copy the path, switch back, paste. The switch costs a couple of seconds and a thread of attention, and it happens dozens of times a day.

Two changes help. One is free: one folder per piece of work, with the project's conventions written into its rules file so they are not retyped. The other is to stop running the file browser and the terminal as separate applications. When a file manager keeps a terminal in the same window, selecting a folder is what opens the shell in it, and the files an agent rewrites stay visible beside the transcript instead of behind another application. The comparison with other file managers sets out what that arrangement changes day to day.

The second gap is time rather than space. Agent runs take minutes and then stop to ask something. Being able to read the running terminal from an iPhone or iPad turns a stalled half hour into a one-line answer from wherever you happen to be.

What to change first

Pick based on where the reading happens. If most of the day is spent reading and editing code, an editor-centered tool keeps the review surface closest to the work. If most of the day is spent running commands, moving files, and delegating longer tasks, a terminal-centered agent fits the existing motion better.

Then fix the layer underneath, because it applies either way: one folder per project, conventions written down, and a window where the folder and the shell sit together rather than one application switch apart. Everything Atriens does on the Mac itself is free, which makes that last piece something to test in a week rather than debate.