Last updated
Cursor is a fork of VS Code with AI built into the editor rather than attached to it. That single architectural decision explains most of what is interesting about the product — why it spread as fast as it did, why it is so easy to trial, and why it can get expensive. The useful question is not what Cursor is. It is whether the way Cursor wants you to work matches the way your codebase actually changes.
Because Cursor is VS Code underneath, adopting it costs close to nothing. Extensions install through the same marketplace flow, keybindings and settings import in a single step, the theme comes across, and the file tree, terminal, and debugger behave the way your hands already expect. There is no week of relearning muscle memory, which is the usual reason developers refuse to even evaluate a new editor.
The underrated consequence is reversibility. Trialling Cursor is not a commitment, because the project you opened is still an ordinary VS Code project and you can go back mid-afternoon having lost nothing. For a team lead deciding whether to run a pilot, that asymmetry matters more than any feature table: the downside of trying is near zero, so the only real question is whether the upside shows up.
The flip side is that none of this applies if VS Code is not where you live. A JetBrains or Neovim developer evaluating Cursor is being asked to change editors, not to add AI, and that is a much harder trade. Our look at why developers leave VS Code for Cursor covers what that transition feels like from the inside.
Most disappointing sessions with Cursor are context problems rather than model problems. The agent answers well when it is looking at the right code and badly when it is guessing, and which of those happens is largely under your control.
Cursor indexes the repository so it can retrieve relevant code semantically instead of relying on whatever you happen to have open, and you can steer that by referencing specific files, folders, symbols, and documentation directly in a prompt. Paths can be excluded from indexing with a .cursorignore file, which is worth doing for generated code, vendored dependencies, and large fixture sets that otherwise dilute retrieval. You can also commit rules files to the repository so every developer's agent inherits the same conventions — naming, banned libraries, what a test is supposed to look like — rather than each person re-explaining house style in every conversation.
Teams that get consistently good output treat those rules as a maintained artefact and review them like any other configuration. Teams that get mediocre output type one sentence into the chat box and blame the model.
Cursor bills against a pool of usage credits rather than a flat allowance of requests, and the practical effect is behavioural more than financial. Frontier models drain the pool quickly; cheaper ones stretch it. Once you notice that, you start rationing — saving the expensive model for the hard problem, running exploratory questions on something lighter, hesitating before firing off a large agent run late in a billing period.
Whether that is good or bad depends on the person. Some developers find the pressure clarifying, because it discourages the habit of throwing an agent at code you have not read. Others find it corrosive: an editor that makes you price a thought before having it is a worse editor, whatever the arithmetic says. Either way, budget by how your team actually works rather than by the sticker price, because two developers on the same plan can have completely different months. Our piece on token economics explains why nearly every tool in this category has drifted toward metering.
Tier names and credit amounts change often enough that any figure quoted anywhere — including here — ages badly. Confirm the current structure on Cursor's own pricing page before committing a team budget.
This is where rollouts usually stall, and it is much cheaper to resolve before the pilot than after. Cursor offers a privacy mode intended to ensure your code is not retained or used to train models, and on business plans it can be enforced across the organisation rather than left to each developer's settings. That enforcement is the part a security reviewer cares about, because a per-user toggle is not a control.
Be clear about what the mode does and does not promise. It is a retention and training guarantee, not local execution: prompts and the surrounding code still travel to a model provider in order to be answered, and building the index involves sending code out to be embedded. If your requirement is that source must never leave your network under any circumstances, this is the wrong shape of product entirely and you should be evaluating self-hosted assistants such as Tabnine. If your requirement is the far more common one — no training on our code, no retention, a report compliance can file — read Cursor's current security documentation and check it against your own policy rather than trusting anyone's summary of it.
Against GitHub Copilot the trade is editor depth versus institutional fit: Cursor's agent does more inside the editor, while Copilot sits closer to pull requests, organisation policy, and a purchasing path most companies have already walked — Cursor vs GitHub Copilot works through it. The rival AI-native editors Cursor is usually weighed against have a habit of being acquired and folded into something else, which is its own argument for the incumbent when you are committing a team's daily workflow for a year. One of them is now literally inside Cursor: Supermaven's autocomplete was folded into Cursor's Tab feature after Anysphere acquired it, as detailed in our rundown of discontinued AI tools. Against generation-first tools like v0 and Bolt.new there is barely a comparison to make, because those start projects and Cursor maintains them. Plenty of developers use one of each.
Do not switch if your editor is not VS Code and you are happy in it. The migration cost that makes Cursor almost free for VS Code users makes it expensive for everyone else, and Copilot reaches your existing IDE through a plugin without asking you to leave.
Do not switch if you need a fixed, predictable monthly cost per developer. Usage-based billing across a team of unknown appetite is a forecasting problem, and finance tends to dislike it more than engineering does.
Do not switch if your review culture cannot absorb larger diffs. An agent that edits ten files at once only makes a team faster if somebody can genuinely read ten files of changes. Otherwise you have converted writing time into review debt, and the gain quietly disappears downstream.
And do not switch expecting an agent to work unsupervised on a codebase nobody on the team understands. Cursor is at its best in the hands of someone who could have made the change themselves and is choosing not to spend the afternoon doing it.
Renaming a concept across a repository, migrating off a deprecated API, pulling a tangled module apart. This is the work where a codebase-aware agent most clearly beats autocomplete, and also the work where the review matters most — the agent is confident in the places it is wrong.
Asking where authentication is handled, what calls a function, or why a config value exists, and getting answers grounded in the actual code rather than in general knowledge about how such things are usually done. For a new joiner this replaces the first week of reading with a conversation.
The route, the form, the validation, the test file that mirrors the one next to it. Cursor compresses the part of the job that is pattern-following rather than thinking, which shifts your attention to the part that is not.
A backend developer touching the deployment scripts, or a frontend developer fixing something in a service they do not own. The agent supplies the idiom you would otherwise spend an hour searching for, and the fact that you can still read the result is what keeps it safe.
Cursor offers Hobby (free, limited completions and agent requests), Pro ($20/mo, or $16/mo annually, with a $20 monthly credit pool, frontier models, MCPs, and cloud agents), Pro+ ($60/mo, 3x usage credits), Ultra ($200/mo, 20x usage), Teams ($40/user/mo with SSO and admin controls), and Enterprise (custom). The pricing trap: since the mid-2025 shift to credit-based billing, your real cost depends on model choice and prompt complexity. Fast Claude Sonnet requests deplete credits quickly while economical models stretch further, so two developers on the same $20 Pro plan can have very different experiences depending on how they work.
No, as long as you already use VS Code. Cursor is a fork of it, so the interface, extensions, settings, and keybindings carry over and can be imported in one step. Most VS Code users are productive the same day. If you use JetBrains or Neovim, the honest answer is different — you would be changing editors, which is a real cost that no feature list offsets automatically.
Less than the pricing page suggests and more than you would like. Each plan includes a credit pool, and different models draw on it at very different rates, so the meaningful variable is which model you reach for and how often you let an agent run long. The practical consequence is that you start making small economic decisions inside your editor, which some developers find focusing and others find distracting.
Yes. A .cursorignore file excludes paths from indexing, which is worth configuring for secrets-adjacent directories, vendored code, generated output, and anything large enough to pollute retrieval. Treat it as a quality setting as much as a privacy one — a tighter index usually produces better answers, not just safer ones.
That depends on what your policy actually requires. Cursor's privacy mode is designed so code is not retained or used for training, and on business plans it can be enforced organisation-wide rather than left to individual settings, which is the part security reviewers ask about. What it does not do is keep code on your machine — prompts and context still go to a model provider to be answered. If your rule is that source cannot leave the network at all, you need a self-hosted tool instead. Read Cursor's current security documentation rather than relying on a summary.
Cursor if the centre of your work is the editor and you want an agent that makes multi-file changes with real codebase context. Copilot if the centre of your work is GitHub — pull requests, issues, organisation policy — or if predictable procurement matters more to whoever signs off than the last increment of editing power. Plenty of teams run both and do not find that wasteful.
It is enough to answer the only question that matters at the start: does this change how the work feels on your codebase, not on a demo repository. The limited completions and agent requests run out quickly under daily use, so treat the free tier as an evaluation rather than a plan.
It is overconfident on tasks that require understanding something the code does not state — an undocumented business rule, a constraint that lives in someone's head, a workaround whose reason was never written down. It will produce a clean, plausible change that violates the rule without hesitating. It is also weak where it has no context to retrieve, which is exactly when a large agent run is most tempting and least advisable.
Full review coming soon.