Cursor

Overview

Cursor is an AI-first code editor built on top of VS Code’s open-source foundation, designed from the ground up so that large language models are a first-class part of the editing experience rather than a plugin bolted on after the fact. Where traditional editors treat AI as a sidebar or an autocomplete suggestion, Cursor bakes codebase awareness, conversational chat, and an autonomous agent directly into the file tree, the diff view, and the command palette. You can try it at https://cursor.com, and it runs on macOS, Windows, and Linux.

In our evaluation, the defining trait of Cursor is that it “thinks in your repository.” Instead of answering questions in isolation, it indexes your project so that chat responses, completions, and multi-file edits are grounded in the actual symbols, imports, and conventions of your code. That makes it especially strong on greenfield work and on refactors that span many files, where a model with no context would otherwise guess blindly. It is not, however, a universal replacement for disciplined engineering: the credit-based pricing model and the telemetry questions around what gets sent to the model divide opinion, and some reviewers find the per-request billing exploitative on heavy days.

Key Features

• Composer for multi-file edits — Describe a feature or a refactor in plain language and Composer plans and applies changes across several files at once, showing you a unified diff before anything lands. In our evaluation this is the single feature that most separates Cursor from inline-only assistants, because it collapses what used to be an hour of copy-paste into a single reviewable changeset.
• Agent mode for autonomous tasks — The agent can read files, run terminal commands, search your codebase, and iterate on its own work, pausing only when it needs your approval. We found it most useful for scaffolding tests, wiring up boilerplate, and chasing down the kind of cross-cutting bug that touches five different modules.
• Codebase-aware chat with @-context — Rather than pasting snippets manually, you can @-mention files, folders, or the whole repo so the model answers with precise, in-repo citations. This keeps answers grounded and spares you the tedious work of copying context into a chat window.
• Tab completion that predicts edits — Cursor’s Tab goes beyond next-line prediction; it can suggest whole-block changes, renames that ripple through a file, and mid-function edits. Many reviewers report it feels noticeably faster and more anticipatory than GitHub Copilot’s default completion.
• Top-model access (GPT, Claude, and more) — You can route requests through leading frontier models and switch per task, which matters when one model is better at reasoning and another is better at terse completions. Our evaluation suggests treating model choice as a per-job dial rather than a one-time setting.

Pricing

Pricing is subject to change. Check the official website for current plans and regional discounts. Free tiers often have usage limits — evaluate whether those limits match your expected volume before committing.

The Hobby tier is genuinely usable for casual work, but the 500 premium-request allowance on Pro is the line that matters for daily users. In our evaluation, premium requests are consumed by the agent, Composer, and the strongest models, so a developer leaning hard on agent mode can hit the cap before the month ends. Business adds org-wide privacy toggles and centralized billing; if telemetry worries you, that tier (or the privacy mode setting) is where you regain control over what leaves your machine.

How It Compares

vs. GitHub Copilot: Copilot’s strength is invisibility — completions appear as you type with zero window switching — whereas Cursor’s strength is reach, editing across files through Composer and an agent. On a specific dimension, Copilot wins for low-friction daily typing; Cursor wins for multi-file refactors and repo-aware reasoning. Our evaluation: pick Copilot if you want a quiet pair, Cursor if you want a junior engineer you can brief.

vs. ChatGPT: ChatGPT is a general assistant you paste code into; Cursor is the editor itself, with the repo as living context. The dimension that matters is round-trips: ChatGPT makes you copy context in and diffs out, while Cursor already knows the files. For one-off conceptual questions either works; for in-codebase edits Cursor removes a whole class of friction.

vs. Claude: Claude (via API or app) is excellent at careful reasoning and long documents, but it has no editor. Cursor can route to Claude under the hood for exactly that reasoning while still applying the result to your files. Our evaluation treats Claude as a model Cursor can use, not a direct competitor, unless you prefer a separate chat workflow.

Getting Started

• Begin with a small, self-contained task — a utility function or a single-file refactor — before trusting Composer with a large changeset, so you learn its edit style on low-risk ground.
• Turn on privacy mode early if the repo is sensitive; in our evaluation the telemetry toggle is the difference between “fine” and “I’d never point this at client code.”
• Scoped @-mentions beat vague prompts: name the exact files and the failing test so the agent burns fewer premium requests and returns tighter diffs.
• Use Tab completion for boilerplate and repetitive blocks first; it builds trust faster than handing over architectural decisions on day one.
• Keep your version control clean and commit before big agent runs, because reviewing a focused diff is far easier than reconstructing what changed.
• Try a quick “explain this file” chat to see how well it indexed your project; weak answers usually mean the context window needs a tighter scope, not a better model.
• Watch your premium-request meter in settings so the 500 cap never surprises you mid-sprint; switch heavy agent work to off-peak or a cheaper model when possible.

Hands-on Verdict

Cursor earns its reputation as the editor we reach for on greenfield codebases, because the agent and Composer genuinely “think in your repo” in a way inline completions never do. In our evaluation the speed-up is real and measurable on refactors, scaffolding, and test generation, and the Tab completion alone justifies the subscription for many developers. Reviewers consistently praise exactly these strengths.

The honest friction is twofold. First, the credit-based pricing and the 500 premium-request ceiling bite heavy users, and the “exploitative” framing some users apply is less about the dollar amount than about not knowing when you’ll hit the wall. Second, the telemetry and privacy posture deserves a real look before you point Cursor at proprietary or regulated code — the privacy toggle helps, but it is a setting, not a default. Our verdict: an exceptional daily driver for repo-aware coding, best used with scoped prompts, a clean git history, and a clear eye on the request meter.