Cursor

What it is

Cursor is an AI-native code editor built as a fork of VS Code by Anysphere, a small San Francisco startup that went from side project to category leader in roughly two years. The pitch is simple: take the editor most developers already know, rebuild the AI surface from the ground up, and make it the first thing the UX is designed around rather than a bolt-on afterthought. That single reframing is the thing that made Cursor the default AI editor for a striking share of working developers.

The original wedge was Tab completion. Not single-token autocomplete — multi-line, multi-file prediction that anticipates where your cursor is headed next, what edits you're about to make on a symbol across the repo, and what the next reasonable diff looks like. It sounds incremental. It isn't. The first day you feel Cursor's Tab predicting a three-line change in another file correctly, the old model of code completion starts to feel quaint. GitHub Copilot eventually shipped its own take; Cursor's version still feels a half-step ahead.

The agentic upgrade is Composer (also referred to as Agent in more recent builds). Composer takes a natural-language prompt and applies coordinated changes across multiple files — a refactor, a feature add, a bug hunt — with a diff preview you approve or reject. It's the feature that lets Cursor compete at the agentic tier with Claude Code CLI and OpenAI's Codex CLI. The in-editor chat ties it all together: ask a question about a file, get answers grounded in your codebase.

Under the hood, Cursor is a model picker, not a model. You route requests between Claude Opus 4.7, GPT-5, Gemini Ultra, and a selection of open-weights options depending on the task. For teams on the Business tier there's Privacy Mode enforced at the organization level, plus SSO, an admin dashboard, and per-user analytics. Rules and Memory let you codify repo-specific conventions so the model stops suggesting the wrong import path for the fifth time.

Positioning-wise, Cursor sits between GitHub Copilot (inside plain VS Code, cheaper, weaker agentic surface) and the terminal-native agentic tools (Claude Code, Codex). For most day-to-day work, it's the best of both — IDE-grade ergonomics with the agentic ceiling of a real coding agent.

What we tested

We've used Cursor as our primary editor across client engagements and internal work for well over a year, spanning the Pro, Business, and Ultra tiers. That covers daily use for writing TypeScript, Python, Go, and the odd Rust project, plus the infrastructure-as-code and shell scripts that sit alongside real product work. It's the editor open on both of our desks right now.

We've put Composer through real multi-file refactors — the kind where you're renaming a domain concept that appears in 40+ files, updating both the API layer and its consumers, and fixing the tests that break along the way. We've used it to scaffold new features from scratch against an existing codebase's conventions, and to hunt bugs across layers. We have opinions about where it shines and where it still produces slop.

On the model side, we've routed the same tasks through Claude Opus 4.7, GPT-5, and Gemini Ultra inside the picker to see which one handles each flavor of work best. Spoiler: Claude Opus is the daily driver for most of our engineers, with GPT-5 as the fallback for certain reasoning-heavy debugging sessions and Gemini Ultra reserved for work that needs long-context comprehension of big repos.

We've also done the migration from plain VS Code — extensions, keybindings, settings sync, the whole ritual. And we've run Cursor's privacy mode against client code where it mattered, with the compliance team looking over our shoulder. None of what follows is a synthetic benchmark. It's what showed up after thousands of hours of real shipping.

What's good

The single biggest reason to use Cursor is Tab completion. It's been the reason for two years running and it's still the reason. Cursor's Tab doesn't just finish the line you're typing — it predicts the next three or four edits you were about to make across the file and sometimes across sibling files, presents them as a coherent ghost-diff, and lets you accept the whole thing with a single keystroke. Once you're calibrated to it, plain VS Code with Copilot feels like it's running at half speed.

Composer is the feature that justifies the price alone if you use it. A prompt like "rename the Account concept to Workspace across the API, the consumers, and the tests, and update the OpenAPI spec" will produce a diff set across the relevant files, present them for review, and land a single reviewable change. For the kind of refactor that used to eat a Tuesday afternoon and ship buggy anyway, Composer shrinks it to a coffee-break's worth of review time.

The model picker is quietly a differentiator competitors don't match cleanly. The ability to route a specific chat or Composer run through Claude Opus 4.7, GPT-5, or Gemini Ultra — from the same editor, without switching tools or managing API keys yourself — means you can pick the right model for the task. Long-context repo comprehension through Gemini, tight code edits through Claude Opus, reasoning-heavy debugging through GPT-5. You pay for the usage via Cursor's credit pool, so it's also one bill.

VS Code extension compatibility is the unsexy feature that made Cursor possible as a switching target. Cursor reads the VS Code extension ecosystem directly — your language servers, your linters, your theme, your git tooling, your debugger. The migration from plain VS Code is measured in minutes, not days. That compatibility is load-bearing: it's why devs actually switch, instead of bouncing after a week of "half my tools don't work."

Privacy Mode on the Business tier is the feature that gets Cursor past enterprise security reviews. With privacy mode enforced org-wide, source code is not retained beyond the request, not used to train models, and not readable by Anysphere staff. It's not zero-trust — the code still leaves your network — but for most teams it's the posture the compliance review was actually asking for. The SOC 2 audit and the documented sub-processors help.

Where Cursor earns its keep

• Tab completion that predicts across lines and files, not just the next token.
• Composer handles multi-file refactors from a single prompt with a reviewable diff.
• Model picker routes Claude, GPT-5, and Gemini from one editor with one bill.
• Full VS Code extension compatibility — migration takes minutes, not days.
• Privacy mode on Business clears most enterprise compliance reviews.
• Rules and Memory codify repo-specific conventions so the model stops re-learning them.

Cursor isn't faster than VS Code. It's faster than you. The Tab prediction pulls you forward half a step at a time, and after a week of it you've forgotten what the old cadence felt like.

Multi-repo workspace support means you can point Composer at a monorepo or at several cloned services side-by-side and have it reason about them together. For anyone working across a frontend repo and a backend repo during a feature — that's almost everyone — this is the capability that makes Cursor feel like it fits the actual shape of your work instead of pretending each repo is a universe.

Common pitfalls

A handful of failure modes show up repeatedly across the teams we onboard to Cursor. None of them are fatal, but all of them cost real money or momentum if you walk into them.

Using free Hobby beyond evaluation. Hobby is a well-designed trial — you get enough Tab and enough Agent to understand whether Cursor fits your brain. It is not a viable daily driver. If you're actively working in Cursor every day and still on Hobby, you're either hitting caps constantly or tuning your workflow around them, which defeats the purpose. Pro at $20 pays for itself inside a week for any working developer.

Ignoring Composer. The most common Cursor anti-pattern we see is a developer who uses Tab brilliantly and never once invokes Composer. Tab is a productivity gain on the work you were already going to do. Composer is a multiplier on the work you'd normally delay or avoid — the refactor, the migration, the test backfill. If you've had Cursor installed for a month and haven't shipped a Composer diff, you're paying for half the product.

Defaulting to the wrong model. The model picker is powerful precisely because it's task-aware — and useless if you leave it on one default forever. For straight edits and refactors, Claude Opus 4.7 is our daily pick. For long-context repo comprehension, Gemini Ultra. For thorny reasoning-heavy debugging, GPT-5. For cost-sensitive Tab-only work, the lighter models are fine. Most teams that complain Cursor "feels dumber lately" have been routing everything through whatever was default three versions ago.

Not enabling privacy mode on sensitive work. On Pro and Ultra (individual tiers), privacy mode is opt-in per workspace. On Business it's enforced org-wide, which is the whole reason Business exists. If you're on Pro and working on client code under an NDA, flip privacy mode on before you open the repo. The default on individual plans is not zero-retention, and that is a discoverable-but-skippable checkbox for a surprising number of users.

Treating Cursor as a general IDE instead of AI-first. Developers migrating from VS Code sometimes never change their habits — they just replace the binary and continue coding the way they always did, occasionally accepting a Tab suggestion. That's leaving 80% of the value on the table. Cursor rewards the developer who learns to think in prompts alongside code: asking chat to explain unfamiliar code before editing, letting Composer handle the boilerplate, driving Tab with intentional cursor position. Change the workflow, not just the editor.

Migrating without bringing extensions. Cursor supports the VS Code extension ecosystem — but only if you actively import your settings and extensions. Teams that install Cursor fresh, never sync their existing config, and then wonder why their linter, debugger, and themes are all wrong end up with a worse Cursor than they needed. Run the "import from VS Code" flow on day one; it's a five-minute difference between "works exactly like my old setup" and "nothing feels right."

What's not

Pro's credit pool is the single most honest complaint about Cursor. At $20/mo you get roughly $20 of frontier-model usage in the included pool — which is generous for Tab-only workflows and restrictive for heavy Composer users. A week of aggressive Composer refactors against Claude Opus can overflow the pool before mid-month. Pro+ at $60 fixes it for most developers, but the fact that the answer is "pay 3×" is a real friction in the value story.

Upstream VS Code churn occasionally lands in Cursor as short-lived instability — a release where the debugger misbehaves for a few days, or where a specific extension breaks until the next patch. These windows are usually measured in days, not weeks, and Anysphere ships fixes quickly, but if you're the kind of team that cannot tolerate any editor jitter, you'll feel it.

The Business tier floor at $40/seat is high for small teams. A three-person startup looking to get enforced privacy mode and an admin dashboard is looking at $120/mo just for editor subscriptions, before a single frontier-model token is burned. For teams where individual Pro subs would cost $60/mo total, that's a 2× markup for org controls. Compliance-driven orgs will pay it without blinking; early-stage teams often choose individual Pro subs and defer the enforcement until they have to.

Claude Code CLI is a real competitor for the agentic tier of Cursor's use cases, and for certain workloads — autonomous long-running agents, overnight refactors, headless runs in CI — it's a better fit. Cursor is an IDE-first product; Claude Code is terminal-first and scriptable. We run both. Most teams will, eventually.

Cost at scale is real. A 20-developer team on Business with reasonably heavy usage is $800/mo for seats plus whatever overage the team burns through in credits — realistically $1,500–$2,500/mo all-in. That's cheap next to the payroll of 20 developers, and expensive next to the $190/mo GitHub Copilot Business alternative. The productivity delta usually justifies it; the CFO still wants the receipts.

Who should use it

For solo developers and independent engineers, Cursor Pro at $20/mo is the right answer. It's the best dollar-for-productivity deal currently shipping in developer tooling, full stop. If you're already paying for ChatGPT or Claude for general chat, pair it with Cursor and you have the entire working dev stack for roughly $40/mo combined.

For small startup teams (3–15 devs), the choice is usually between individual Pro subscriptions and Business. If your team handles sensitive client code, if you need per-user analytics, or if your procurement team is asking questions about enforcement — go Business at $40/seat. If the team is pre-revenue, building in the open, and doesn't yet need compliance posture — individual Pro subs are cheaper and equally capable editorially.

For agencies shipping work for clients, Business is almost always correct. Privacy mode enforced at the org level is the line the security review team will actually want to see in the questionnaire. Per-user analytics also help when you're billing clients for engineer time and want to ground the conversation in real usage.

For open-source maintainers, Pro is usually enough, and for the ones maintaining very large projects, Pro+ or Ultra's bigger credit pools pay for themselves on Composer-driven refactors alone. The model picker means you can route OSS work through whichever provider you're most comfortable with license-posture-wise.

For enterprises with established AI policies, Business or Enterprise. The audit log, AI code-tracking API, and SCIM on the Enterprise tier are the features procurement actually cares about, and the per-seat pricing scales linearly rather than jumping. If your org has already green-lit Claude or ChatGPT at the workspace level, Cursor on top is usually a shorter security review than the first one was.

A note on Cursor vs. Claude Code: they're complementary, not competitors, for most teams. Cursor is an IDE — interactive, visual, tight-loop. Claude Code is a CLI — scriptable, headless, long-running. Use Cursor for the 80% of your day where you're actively editing with the model in the loop. Use Claude Code for overnight refactors, CI-driven agent workflows, and anything you'd rather hand off to a background process. Teams that run both tend to be happier than teams that try to force one to do the other's job.

Verdict

Cursor is the AI editor most working developers have already switched to, and the switching was rational. Tab completion is category-defining; Composer is the first agentic in-editor experience that actually survives contact with a real codebase; the model picker buys you model-choice optionality without key-management overhead. The migration cost from VS Code is essentially zero. The productivity delta is large and measurable within the first week.

We rate it 9.2 / 10. It loses points for the credit-pool friction on Pro for heavy Composer users, the Business-tier floor that prices out the smallest teams from enforced privacy, and the occasional VS Code-churn jitter. It gains them everywhere else — especially on the core editor experience, which is the bar most AI-dev-tool companies are trying to clear and haven't.

If you're a working developer on the fence, install Hobby tonight, do real work in it for three days, and then upgrade to Pro. You'll know within a week whether it belongs in your stack. For most of the developers we watch try it, the answer is yes, and the only follow-up question is how they worked without it.