---
title: "Cursor review: the AI editor that goes beyond prototypes"
description: "Is Cursor worth paying for? Agent, Plan Mode, cloud agents, rules, prices from the official page and the traps to avoid before you subscribe."
url: "https://vibe-code.blog/en/cursor-review"
lang: "en"
author: "Thierry Gustin"
published: "2026-09-14"
updated: "2026-11-21"
---

# Cursor review: the AI editor that goes beyond prototypes

> **Key takeaways** — Cursor is a code editor built on VS Code, with an agent that reads your project, edits multiple files and runs commands. It suits people who want to own real source code rather than a prototype locked in a browser builder. As of November 21, 2026, plans run from $0 to $200 a month, and third-party models such as Claude and GPT are billed on top at API prices from the Premium plan up.

Cursor is the tool people reach for when a prototype built in [Lovable](https://lovable.dev/) or Bolt starts to creak. Our Cursor review in one sentence: it is a full code editor, built on VS Code, with an AI agent that works directly in your files. You gain control and power; you lose the comfort of doing everything in a browser tab. Here is what stands out from the documentation, the pricing and published feedback.

## What exactly is Cursor?

Cursor is a desktop code editor (macOS, Windows, Linux) built on the VS Code codebase, with AI woven into every layer. The official docs put it plainly: "Cursor is based upon the VS Code codebase". In practice, your VS Code extensions, themes and keybindings import in one click.

Where [Lovable, Bolt and Replit](https://vibe-code.blog/en/lovable-vs-bolt-vs-replit) hide the code behind a live preview, [Cursor](https://cursor.com/) puts the code in front of you. You work on a folder on your own machine, tracked with Git, which you can deploy anywhere.

Since August 14, 2026, Cursor has been owned by SpaceX, according to the announcement on Cursor's blog. For users, the visible effect is that Cursor's in-house models (Composer and the Grok family) are front and center in the plans.

### The four building blocks

| Feature | What it does | When to use it |
| --- | --- | --- |
| Tab | Autocomplete that suggests multi-line edits, even in other files | When you write or tweak code yourself |
| Agent | Reads the project, edits files, runs terminal commands | For a feature, a bug fix, a refactor |
| Plan Mode | The agent asks questions, explores the code and writes a plan before touching anything | For anything that spans several files |
| Cloud Agents | Agents running in Cursor-hosted virtual machines, in parallel, even with your laptop closed | For long or multiple tasks you want to delegate |

## What Cursor's agent can do

Cursor's agent can carry a task end to end: search the codebase, read and edit files, run shell commands, search the web and drive a browser to check what a page looks like. The documentation states there is no limit on the number of tool calls during a task.

Three features matter most for vibe coders:

- **Checkpoints.** Cursor snapshots your files before significant changes. If the agent goes off the rails, click a checkpoint and everything is restored. The docs are clear that this does not replace Git: checkpoints are local and only meant for undoing agent changes. For the rest, read [our Git guide for vibe coders](https://vibe-code.blog/en/git-for-vibe-coders).
- **Message queue.** While the agent works, you can type your next instruction and it waits until the current task finishes. Or you can send it immediately to steer the agent.
- **Run Modes.** You set the level of autonomy: "Auto-review" (known-safe calls run, others go to a sandbox or a classifier review), "Allowlist" (only approved commands run), or "Run Everything" (everything runs, at your own risk).

> **Don't use "Run Everything" on your main project** — This mode runs every command without asking. One misunderstood destructive command and your folder is gone. Stay on "Auto-review" until you read every command.

### Plan Mode: the habit that prevents disasters

Plan Mode is toggled with Shift+Tab in the agent input. Instead of coding right away, Cursor asks clarifying questions, explores your project, writes an editable plan and waits for your approval. If the result misses the mark, the docs recommend going back to the plan and rerunning rather than patching through follow-up messages: "This is often faster than fixing an in-progress agent".

That is the same logic as [writing the spec before the prompt](https://vibe-code.blog/en/prd-for-ai-builders): the hard part is knowing what to build.

### Rules: giving the agent a memory

Models remember nothing between conversations. Cursor makes up for it with rules, injected at the start of the context:

- **Project rules** in `.cursor/rules`, as `.mdc` files (a plain `.md` file in that folder is ignored).
- **AGENTS.md** at the project root, in plain markdown, also read by other agents such as Codex.
- **User rules**, global to your installation.
- **Team rules**, managed from the dashboard on Teams and Enterprise plans.

Here is a starter rule to drop into `.cursor/rules/base.mdc`:

```md
---
alwaysApply: true
---

- Before changing code, read the relevant files and summarize what you are about to change.
- Never touch .env files or API keys; never put a secret key in front-end code.
- After every change, run `npm run build` and fix errors before handing back.
- If a request is ambiguous, ask me a question instead of guessing.
```

The second line is there for a reason: [an API key in the front end](https://vibe-code.blog/en/api-keys-security) is still the most expensive mistake in vibe coding.

## How much does Cursor cost?

Cursor has a limited free plan and subscriptions from $8 to $200 a month. Prices checked on November 21, 2026 on the [official pricing page](https://cursor.com/pricing) and the "Models & Pricing" documentation:

| Plan | Monthly | Annual | Included usage | Third-party models (Claude, GPT…) |
| --- | --- | --- | --- | --- |
| Free | $0 | — | Limited | No |
| Plus | $8 | $80 | Base | No (Cursor models only) |
| Premium | $30 | $300 | 4x Plus | Yes, at API list price from prepaid credit |
| Super | $100 | $1,000 | 15x Plus | Yes, at API list price |
| Ultra | $200 | $2,000 | 50x Plus | Yes, at API list price |
| Teams | $30, $100 or $200 per seat | — | Matches the seat tier | Yes, API price plus a Cursor rate |

Prices exclude tax. Included usage refreshes weekly and only covers Cursor's own models. Cloud Agents, Automations and Bugbot code review start at Premium.

> **The third-party model trap** — If you want Claude or GPT inside Cursor, the subscription is not enough: those models are billed on top, at public API prices, from credit you top up. Set a spending cap on day one.

Subscribers on the older plans (Pro at $20, Pro+ at $60, Ultra at $200, Teams at $40 per user) can keep them, according to Cursor's documentation page on legacy plans.

To estimate your project's total cost, subscriptions included, read [what a vibe-coded app really costs](https://vibe-code.blog/en/vibe-coding-cost).

## Strengths and weaknesses

### Where Cursor shines

- **Real code, on your machine.** No lock-in: your project is a standard Git folder. You can switch tools tomorrow.
- **The VS Code ecosystem.** Every extension, the built-in terminal, the debugger. If you have used VS Code before, you are at home.
- **Plan Mode and checkpoints.** Two guardrails that limit the damage of an over-eager agent.
- **Cloud Agents.** Run several tasks in parallel on remote machines, started from the desktop app, the web, the iOS app, Slack or an `@cursor` comment on GitHub.
- **Bugbot.** Automatic review of every pull request, with comments on likely bugs and security issues (Premium and up).

### Where it can hurt

- **No built-in hosting or database like Lovable.** You wire up [Supabase](https://supabase.com/), a host and environment variables yourself. See [our hosting comparison](https://vibe-code.blog/en/deploy-vibe-coded-app).
- **The learning curve.** A code editor is intimidating if you have never opened a terminal. This is not a zero-tech tool.
- **Third-party model bills.** Claude and GPT are pay-as-you-go on top of the subscription: the bill depends on your discipline.
- **A plan structure that takes reading.** Between weekly usage, prepaid credit and multipliers, you need the docs to know what you are paying for.

## Is Cursor right for you? A decision tree

- **Never seen code and want a prototype this weekend?** Start with [Lovable, Bolt or Replit](https://vibe-code.blog/en/lovable-vs-bolt-vs-replit). Cursor can come later.
- **Your Lovable or Bolt prototype has outgrown the chat?** Push the code to GitHub and open it in Cursor. That is the ideal use case.
- **Prefer a terminal to an editor?** Look at [Claude Code](https://vibe-code.blog/en/claude-code-beginners-guide) or [OpenAI Codex](https://vibe-code.blog/en/openai-codex-review).
- **Torn between all three?** Our [Cursor vs Claude Code vs Codex comparison](https://vibe-code.blog/en/cursor-vs-claude-code-vs-codex) settles it by profile.
- **Want a rival editor?** [Windsurf](https://windsurf.com/) plays in the same category, and [our roundup of the best vibe coding tools](https://vibe-code.blog/en/best-vibe-coding-tools) places Cursor against all the others.

## Getting started with Cursor in 5 steps

1. Download Cursor from the official site and sign in. Import your VS Code settings if you have them.
2. Open your project folder (ideally already tracked with Git).
3. Open the agent panel (Cmd+I on Mac) and ask: "Explain this codebase, its entry points and what I should read before changing anything."
4. Create your base rule in `.cursor/rules` (the template above).
5. For your first real feature, switch to Plan Mode, review the plan, then build. Check the diff and ask the agent to run the build and tests.

To phrase those requests well, keep [the 5-step prompting method](https://vibe-code.blog/en/vibe-coding-prompts) at hand, and before going live, run through [the security checklist](https://vibe-code.blog/en/vibe-coding-security).

## Frequently asked questions

## Frequently asked questions

### Is Cursor free?

Cursor has a Free plan at $0 with limited Agent and Chat usage, no third-party models and no Cloud Agents. It is enough to try the editor and Tab autocomplete, not to run a real project. The first paid plan, Plus, costs $8 a month as of November 21, 2026, but it is limited to Cursor's in-house models.

### Can you use Claude or GPT in Cursor?

Yes, from the Premium plan at $30 a month. Those third-party models are not part of the subscription's included usage: they are billed at their public API price and drawn from prepaid credit. Set a monthly spending limit in your settings so the end-of-month bill does not surprise you.

### Do you need to know how to code to use Cursor?

You don't need to be a developer, but you must be comfortable seeing code, a terminal and error messages. Cursor hides nothing. If you are a complete beginner, start with an all-in-one builder, then move to Cursor when the project grows. Learning Git basics and how to read a diff will save you a lot of time.

### What is the difference between Cursor and VS Code with Copilot?

Cursor is a standalone editor built on VS Code with its own AI features: Tab autocomplete, Agent, Plan Mode, Cloud Agents and Bugbot. VS Code with GitHub Copilot is Microsoft's editor with GitHub's assistant added on. Both offer an agent mode; the differences come down to ergonomics, available models and price.

### Is my code used to train models?

With Privacy Mode turned on, Cursor states that your code is never used for training by Cursor or by model providers. Privacy Mode is on by default for Enterprise teams. Check the setting in your account before opening a client project or anything sensitive.

## Sources

- [Pricing — Cursor](https://cursor.com/pricing)
- [Models & Pricing — Cursor Docs](https://cursor.com/docs/models-and-pricing)
- [Legacy Cursor plans — Cursor Docs](https://cursor.com/docs/account/pricing/legacy-cursor-plans)
- [Cursor is now a part of SpaceX — Cursor Blog](https://cursor.com/blog/joining-spacex)
- [Cursor Agent overview — Cursor Docs](https://cursor.com/docs/agent/overview)
- [Plan Mode — Cursor Docs](https://cursor.com/docs/agent/plan-mode)
- [Rules — Cursor Docs](https://cursor.com/docs/rules)
- [Run Modes — Cursor Docs](https://cursor.com/docs/agent/security/run-modes)
- [Cloud Agents — Cursor Docs](https://cursor.com/docs/cloud-agent)
- [Bugbot — Cursor Docs](https://cursor.com/docs/bugbot)
- [Tab completion — Cursor Help](https://cursor.com/help/ai-features/tab)
- [VS Code Migration — Cursor Docs](https://cursor.com/docs/configuration/migrations/vscode)
- [Privacy and data governance — Cursor Docs](https://cursor.com/docs/enterprise/privacy-and-data-governance)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · November 21, 2026
