Cursor review

Direct verdict

Cursor is worth a serious trial when you want an agent to search a repository, make coordinated edits, run project tools, and show the resulting diff in one workflow. It is a weaker purchase if you mainly want autocomplete, cannot approve its data flow, or will not review and test agent changes.

The score on this page is 8/10 as an equal-weight editorial workflow rating, not a universal quality benchmark or a claimed hands-on benchmark. Cursor has a broad, current developer workflow, but value depends on the plan, model, repository, task, and review discipline.

Last verified: August 24, 2026. Pricing, product surfaces, Agent behavior, Plan Mode, Rules, Agent Review, security defaults, and data-use claims were checked against current official Cursor documentation. Prices and features can change; use the linked live pages before buying.

Who this review is for

• Developers deciding whether Cursor adds enough value beyond their current editor
• Existing Hobby or Start users comparing an individual paid plan
• Teams reviewing Agent controls, data handling, and code-review workflow
• Cursor users following old .cursorrules, Composer-mode, or fast-request tutorials

This review focuses on the decision to use or pay for Cursor. For installation, shortcuts, current Project Rules, and a complete safe workflow, use the Cursor AI complete guide.

How this review was evaluated

No unverifiable “months of production use” claim is used here. The review scores seven documented workflow dimensions equally; each contributes one seventh of the final rating.

These scores total 56; dividing by seven produces the displayed 8/10. This is an editorial judgment from the verified product design and policies. It does not replace a same-task evaluation on your repository.

For your own decision, record task completion, scope control, checks run, review time, recovery, approved data flow, and cost per accepted result. A tool that writes more code is not automatically more valuable; it must reduce total time after review, correction, and verification.

What Cursor includes now

Cursor is no longer only a VS Code-like editor with chat. Its current workflow includes:

• a classic Editor for files, terminals, extensions, Tab, and Inline Edit
• an Agents Window for managing agent-heavy work across projects
• Agent for repository search, file edits, commands, browser work, and longer tasks
• Plan Mode for research and a reviewable implementation plan before building
• Project Rules in .cursor/rules/*.mdc plus AGENTS.md support
• diff review, checkpoints, Git and pull-request surfaces
• Agent Review and separate Bugbot workflows for code review
• selectable models and routing options whose availability depends on plan and rollout

The Editor can import VS Code settings and extensions, but that is not a promise that every extension or every Cursor surface behaves identically to VS Code. The Agents Window is a distinct agent-first interface.

Cursor pricing on August 24, 2026

The old “fast requests plus unlimited slow requests” description is obsolete. Current cost depends on the plan's usage pools, the selected model, token consumption, and optional on-demand usage. Taxes also vary; the India-only Start price is documented as tax-inclusive while other individual prices may be shown before tax.

Do not choose a plan from one average request count. Run the same representative tasks, inspect the usage dashboard, and calculate cost per accepted result.

Where Cursor can earn its price

Repository-aware Agent work

Agent can search relevant files, trace callers, edit multiple files, and run commands. This removes copy-paste work when the task genuinely depends on repository state.

The value is not “the AI knows the whole codebase.” Cursor searches and retrieves relevant context; finite model context and missed dependencies still exist. Ask Agent to cite the files behind an explanation and verify the callers yourself.

Plan Mode for larger changes

Plan Mode is useful when a feature has several valid designs or affects multiple systems. Agent researches the repository, asks questions, and produces an editable plan. You choose when to build from it.

This is a meaningful control because ordinary Agent edits may be applied and saved while it works. Plan review reduces architectural churn before code is written; it does not remove the need to review the implementation.

Version-controlled instructions

Current Project Rules live in .cursor/rules/*.mdc and can apply always, intelligently, to matching files, or manually. Plain Markdown AGENTS.md files provide a simpler alternative and can be nested for scoped instructions.

Rules are valuable for stable facts: architecture, canonical examples, commands, and prohibited changes. They are not a replacement for lint, types, tests, or a clear task. Cursor's current Rules FAQ says rules do not control Tab completions.

Review and recovery surfaces

Cursor exposes live and final diffs, checkpoints, Git integration, and Agent Review. These improve visibility, but none proves correctness.

Cursor documents checkpoints as local snapshots separate from Git. Use them for short-term Agent recovery and Git for permanent history. Review every changed file, especially when the task touches auth, payments, migrations, secrets, build configuration, or public APIs.

The limitations that matter

File edits can happen before approval

Cursor's security documentation states that Agent can modify workspace files without approval, except protected configuration cases, and saves changes to disk. Depending on your development setup, auto-reload can execute a change before the final review.

Watch the run, keep a known Git state, and use a disposable local environment for risky tasks. The diff is where you inspect changes; it is not a universal “Accept before anything changes” gate.

Usage and model choice complicate cost

Different models consume included usage at different rates. Routing options, pools, and plan availability can change. A plan that fits small refactors may not fit several parallel agents or long-context work.

Measure a normal week. Record model, task, token or usage charge, accepted-result rate, and correction time. Upgrade only when that evidence shows the cheaper tier is the bottleneck.

Quality is not a product-wide constant

Agent quality varies with the selected model, repository, prompt, rules, tool results, and task. Claims such as “clean 3–6-file refactors” are not guarantees.

A strong evaluation includes:

• one known bug with a known correct fix
• one small refactor with existing tests
• one unfamiliar code-path explanation
• one failure case where a command or test breaks
• one intentionally over-broad prompt to test scope control

Run the same set before and after changing model or plan.

VS Code compatibility needs verification

The classic Editor supports VS Code-style extensions and importing settings. Critical extensions can still depend on versions or behavior Cursor does not reproduce. Test debuggers, remote-development tools, formatters, language servers, and security extensions before switching a team.

Data flow requires a real review

Cursor sends prompts and relevant code context through its backend to model providers when AI features run.

Its data-use page currently states that, with Privacy Mode enabled, Customer Data is not used for training by Cursor and providers are covered by zero-data-retention agreements, subject to abuse-detection handling and explicitly enabled non-ZDR model exceptions. When Privacy Mode is disabled, Cursor says codebase data, prompts, editor actions, snippets, and other code data may be stored or used to improve features and train models.

Codebase indexing uploads code chunks to compute embeddings; embeddings and metadata such as file names and hashes may be stored, and encrypted file contents may be cached temporarily. Requests still pass through Cursor's backend when using your own API key. Cursor's ZDR arrangement does not apply to BYOK requests; the selected provider's privacy and retention policy governs that model request.

A .cursorignore file helps block indexed and direct Agent access to named paths, but Cursor documents that terminal and MCP tools can still access ignored files. Keep secrets outside the repository and treat tool permissions as a separate boundary.

Who should consider paying

Pro or higher may fit when:

• Agent completes repeatable repository tasks with less total review time
• you use Plan Mode and real project checks rather than accepting drafts
• the documented data flow is approved for the repository
• usage records show the free or Start tier is the actual constraint
• cloud, review, model-pool, or team features solve a specific need

Stay on Hobby or Start while evaluating when:

• you are still testing task fit
• most value comes from Tab or occasional small Agent requests
• you have not measured accepted-result cost
• you do not yet have Git, review, and validation habits

Do not adopt Cursor for a repository when:

• policy prohibits the active data flow or model provider
• secrets cannot be separated from tool access
• the team will not review immediate file changes
• required extensions or environments fail migration testing
• another existing tool already solves the measured workflow at lower total cost

A fair seven-task evaluation

Use a non-production branch or practice repository and run:

1. Ask for the architecture and require source-file citations.
2. Fix a known bug without changing its public contract.
3. Add one validation failure test.
4. Refactor a small repeated pattern across two or three files.
5. Use Plan Mode for a larger change but do not build it.
6. Trigger a failing check and see whether Agent finds the root cause.
7. Restore an Agent checkpoint, then confirm Git state.

For each task, record:

Task:
Model or routing mode:
Files changed:
Checks actually run:
Result accepted: yes/no
Manual correction time:
Review time:
Usage charged:
Unexpected behavior:

Compare that total with your current workflow. This is more useful than a generic “best AI editor” ranking.

Common mistakes

Following legacy rules advice — .cursorrules is a legacy format. Use current Project Rules in .cursor/rules/*.mdc or a simple AGENTS.md.

Assuming Agent proposes but never writes — Agent edits are applied as it works. Keep Git available and watch the file list and diff.

Treating every model as interchangeable — use the current model picker and run the same evaluation set. Do not copy a permanent default model from an old review.

Using one broad rule for everything — scope stable instructions by files or domain. A frontend rule should not control a database migration.

Confusing retrieval with total understanding — ask for evidence and inspect direct callers. Indexing does not provide missing business history.

Buying from advertised limits alone — plan features and included usage do not tell you cost per accepted task.

Treating Privacy Mode as secret management — keep secrets outside the repository, use .cursorignore, and restrict terminal and MCP tools.

Troubleshooting

Agent changes unrelated files — stop it, inspect the complete diff, and restore deliberately if needed. Refine the goal, preserved behavior, and acceptance criteria. For a design problem, return to Plan Mode.

A Project Rule is ignored — confirm the .mdc extension, enabled status, application type, description, glob, and whether a matching file is in context. Rules do not govern Tab.

Usage disappears faster than expected — inspect the dashboard by model and task. Large context, long output, retries, and parallel Agent work can change consumption.

An imported extension fails — reproduce it in the classic Editor, compare supported versions, and keep the previous editor available until critical tooling passes.

A diff is too large to review — restore or revert, separate formatting from behavior, and split the task. Do not approve a large opaque diff merely because tests pass.

Review checklist

• [ ] Current plan and live pricing checked
• [ ] Representative repository tasks completed
• [ ] Usage and correction time recorded
• [ ] Agent file-write behavior understood
• [ ] Plan Mode tested without immediately building
• [ ] Project Rules use .cursor/rules/*.mdc or AGENTS.md
• [ ] Complete diff and actual checks reviewed
• [ ] Checkpoint recovery and Git recovery understood
• [ ] Privacy Mode and enabled models reviewed
• [ ] Indexing, BYOK/backend, terminal, MCP, and .cursorignore boundaries reviewed
• [ ] Critical VS Code extensions tested
• [ ] Team or Enterprise claims verified on the live plan page

FAQ

Is Cursor free?

Hobby is free with limited usage. Cursor also documents an India-only Start tier and several individual and team paid tiers. The exact limits and feature packaging change, so use the live Models & Pricing page rather than an old request-count table.

Is Cursor Pro worth $20 per month?

It can be when measured Agent work saves more review-adjusted time than the subscription costs. It is not automatically worth it for autocomplete-only use. Run the evaluation above and inspect actual usage before upgrading.

Does Cursor store or train on my code?

The answer depends on Privacy Mode, provider and abuse-detection handling, indexing, enabled non-ZDR models, tools, and workspace configuration. Review Cursor's current data-use page and your organization's requirements; do not reduce the answer to “stored” or “not stored.”

Does using my own API key bypass Cursor?

No. Cursor's data-use page says requests still pass through its backend for final prompt construction. Cursor's ZDR arrangement does not apply to BYOK requests, so the selected provider's privacy and retention policy governs that request.

Does Cursor know my whole codebase?

Agent can search and retrieve relevant files and chunks. It does not place the entire repository into every request, and finite context still matters.

How is Cursor different from VS Code plus an AI extension?

Cursor combines its Editor, Agents Window, repository tools, rules, Plan Mode, review, and cloud workflows as one product. Other editors and extensions also evolve, so compare both products on the same current tasks instead of relying on a permanent feature checklist.

Official Cursor sources checked

• Models & Pricing
• Pricing
• Agent overview
• Plan Mode
• Agent Review
• Rules
• Agent Security
• Ignore file
• Agents Window
• Data Use & Privacy
• Privacy and data

Takeaways

Cursor's strongest case is a repository-aware workflow that connects research, planning, implementation, commands, and review. Its main costs are not only subscription price: immediate file changes, usage variability, data-flow review, and human verification all matter.

Test the current product on repeatable tasks, record accepted-result cost, and choose the smallest plan that supports the measured workflow.