Quick answer
Cursor is still the strongest AI code editor for professional developers, but the plan most people bought no longer exists. Since October 12, 2026, Cursor is sold as part of The X Subscription: Plus at $8/month, Premium at $30/month, Super at $100/month and Ultra at $200/month. Premium is the real replacement for the old $20 Pro plan. It is $10 more, and Claude, GPT and Gemini are no longer included in the price.
If you write code professionally most days and you are happy working mainly with Grok models, Premium is worth it. If your workflow depends on Claude or GPT, the math changed, and a cheaper setup may fit you better.
This review covers what Cursor does, what the SpaceX acquisition changed, what each new plan includes, how it compares to GitHub Copilot and Devin Desktop (formerly Windsurf), and who should skip it.
What Cursor is — and what it is not
Cursor is an AI code editor built on VS Code. The interface is nearly identical — same keyboard shortcuts, same extensions, same file structure.
The architectural difference is what matters. GitHub Copilot and similar tools are plugins layered onto an existing editor — they read the current file and whatever context you manually provide. Cursor is built differently: the AI is part of the editor architecture, and on setup it indexes your entire codebase. Every function, type definition, naming convention, and directory structure gets mapped. Every AI interaction draws on that complete picture by default, without you pasting anything.
In practice this means Cursor understands your code the way a developer already familiar with your project would. When you ask it to add a feature, it references how you built similar features elsewhere. When it writes new code, it uses your naming conventions and follows your existing patterns without you specifying them in each prompt.
The most useful feature built on this context is agent mode, called Composer. You describe a task in the Composer panel in plain English. The agent reads which files are relevant, writes changes across all of them, runs terminal commands to check compilation and tests, reads the output, and iterates. You review and accept or reject each proposed change. For tasks like 'add rate limiting to all API endpoints' or 'migrate this module from class components to hooks,' the agent handles the mechanical steps while you handle the judgment calls.
We have not measured time savings ourselves, so treat any figure quoted for this as unverified. The value is clearest on tasks that are well-defined but tedious — writing the tenth function that follows the same pattern as the previous nine, or tracing a bug through several layers of an unfamiliar codebase.
Cursor is not a tool for people who cannot code. Cursor generates code you need to read, review, and maintain. If you cannot do that, the tool gets you stuck the moment something breaks — and it will break. For non-developers who want to build software without writing code, Lovable and Bolt are the right tools. Lovable generates full React applications from plain English descriptions, deploys them automatically, and connects them to a database — no coding knowledge required. Bolt is faster for simple pages and prototypes. Cursor is for developers. Lovable and Bolt are for everyone else.
What changed in 2025 and 2026
Two changes matter before you pay for Cursor.
October 2026: new owner, new plans. SpaceX announced a deal to buy Cursor's maker Anysphere on June 16, 2026, and on October 12 the pricing was rebuilt around The X Subscription, one plan that bundles Cursor with Grok and X Premium. The Hobby, Pro, Pro+ and old Teams plans are gone. Every paid tier now draws from one usage pool shared between Cursor and Grok, and that pool refreshes weekly instead of monthly, so one heavy day does not wipe out your month.
The bigger shift is model access. On Plus ($8), you only get Grok models, with no cloud agents. On Premium and above, Claude, GPT and Gemini are still available, but they are billed separately at API list price on top of the subscription. Under the old Pro plan, those models came out of your included credits. If most of your agent sessions ran on Claude, your real monthly cost is now $30 plus whatever that usage costs.
If you are already on the old Pro plan, you can keep it: Cursor lets existing subscribers stay on their plan and price, with their included third-party allowance, or switch. Switching is permanent, and Cursor says legacy plans keep working unless you change or cancel. The Cursor pricing guide covers how to decide, and our Cursor vs GitHub Copilot comparison sets the price against the $10 alternative.
June 2025: the credit model. Before all this, Cursor moved Pro from 500 fixed fast requests to $20 of usage credits, which gave heavy Claude users fewer requests than before. That was the change that sent some users to Windsurf. Windsurf is now Devin Desktop, priced at $20/month for Pro, so the price gap that drove that migration has closed.
On the product side, background agents (now called cloud agents) became genuinely useful in 2026. You queue a large refactor or test generation job, close the laptop, and the agent keeps running on Cursor's infrastructure. They are included from Premium up, not on Plus.
The features worth knowing
Tab completion is where most developers notice the difference first. Cursor predicts your next edit using context from your full codebase, not just the current file. The model handles multi-line predictions — often anticipating the next 5-10 lines correctly in a single tab press. On large projects where the same pattern exists elsewhere in the codebase, accuracy is noticeably higher than GitHub Copilot because Cursor has already indexed and understood those patterns. You do not prompt for this behaviour — it happens automatically.
Composer is the agent mode. You describe a task in plain English in the Composer panel. The agent identifies relevant files, writes changes across all of them, runs terminal commands to catch compilation errors or failing tests, reads the output, and iterates until the task is done or it hits something requiring your judgment. You review every proposed change before it is applied.
Composer works best on tasks with clear requirements and verifiable outcomes: adding a new API endpoint with tests, refactoring a module to a different pattern, generating test cases for existing functions, migrating components between state management approaches. It works less well on tasks that require understanding business context beyond what is in the code itself. Expect to review every output and catch errors — the value is that the starting point is much closer to working code than starting from scratch, and the mechanical work of opening files and writing boilerplate is handled for you.
In standardised testing from early 2026, Cursor completed a multi-component feature build in 2 rounds of prompting. Windsurf needed 3; GitHub Copilot Workspace needed 5 with manual corrections between attempts. See the full Cursor vs Windsurf breakdown for methodology and results. The gap reflects Cursor's full codebase context and the maturity of the agent implementation.
Model access now depends on the plan. Grok models are included in every paid tier, and Grok 4.7, released in September 2026, is the default for long agent runs. On Premium and above you can still switch to Claude, GPT or Gemini mid-session, but that usage is billed separately at API list price. In practice, most developers will run routine work on Grok and switch to a third-party model only for the tasks where it clearly does better.
MCP (Model Context Protocol) support lets you connect external data sources — your internal documentation, API specs, database schemas — directly into the agent's context. For teams with detailed internal documentation or non-standard APIs, this eliminates the step of manually providing context every session.
Background agents, significantly improved in 2026, allow long-running tasks to run independently. A large codebase migration, a full test suite generation, or multi-module documentation can run while you work on other things or step away entirely. A notification arrives when the agent finishes. For tasks that previously required an active session to supervise, background agents change the practical economics of using Cursor on large codebases.
Cursor pricing in October 2026
Five individual tiers, and two matter for most developers. Prices below are from cursor.com/pricing, checked on October 22, 2026. All paid plans include X Premium perks, which most developers will ignore.
Free ($0): limited agent and chat requests. Enough to see whether the editor fits your workflow, not enough for daily work.
Plus ($8/month): Grok models only, with a basic shared usage pool. No cloud agents, no AI code reviews and no Claude or GPT. Cursor itself recommends Plus for social creators with light AI use, and that is accurate: it is not a coding plan.
Premium ($30/month): the real successor to the old Pro plan. 4x the usage of Plus, the latest Grok models, cloud agents and automations, AI code reviews through Bugbot, and access to third-party models at API list price. This is the floor for professional use.
Super ($100/month): 15x the usage of Plus plus priority model access at peak times. Cursor recommends it for daily agent users. It makes sense when you hit the Premium limit most weeks.
Ultra ($200/month): 50x the usage of Plus and earliest access to new models. Only relevant if you run several cloud agents in parallel all day.
Teams (from $30/user/month): pooled usage across the team, SSO, centralised billing, usage analytics, and the option to mix seat tiers.
The honest framing on Premium vs GitHub Copilot: Premium costs three times Copilot Pro at $10/month, and Claude or GPT usage costs extra on top. That premium is worth paying only if you use agent mode and cloud agents regularly. If your main need is good autocomplete and occasional chat, Copilot gives you most of that value for a third of the price.
| Plan | Monthly cost | Usage | Best for |
|---|---|---|---|
| Free | $0 | Limited agent and chat requests | Trying the editor |
| Plus | $8/mo | Basic pool, Grok models only | Light use, not real coding work |
| Premium | $30/mo | 4x Plus, cloud agents, third-party models at API price | Professional developers (replaces old Pro) |
| Super | $100/mo | 15x Plus, priority access at peak times | Daily heavy agent users |
| Ultra | $200/mo | 50x Plus, earliest model access | Several cloud agents running all day |
| Teams | From $30/user/mo | Pooled usage, SSO, admin controls | Engineering teams |
Cursor vs Devin Desktop vs GitHub Copilot
Three comparisons cover most of what developers are actually deciding between.
Cursor vs Devin Desktop, formerly Windsurf ($20/month Pro)
Windsurf is now Devin Desktop, after Cognition's rebrand. Pro costs $20/month and includes cloud agents (Devin Cloud) and free use of its own SWE-2 model, with extra usage at API pricing. That makes it $10 cheaper than Cursor Premium at the entry level.
On capability, Cursor is still ahead on multi-file work. In standardised testing from early 2026, Cursor completed a multi-file feature task in 2 rounds of prompting; Windsurf needed 3. The real difference now is workflow: Cursor keeps you steering the code, Devin Desktop leans on autonomous agents. If you want third-party models included in your subscription price rather than billed on top, compare both pricing pages before choosing. The full breakdown is in our Cursor vs Windsurf comparison.
Cursor vs GitHub Copilot ($10/month Pro, $39/month Pro+)
GitHub Copilot is the most flexible tool by IDE coverage. It runs in VS Code, JetBrains IDEs, Visual Studio, Vim and Neovim, while Cursor is its own VS Code-based editor. For developers or teams with mixed editor preferences, Copilot is the only realistic option.
On autocomplete quality, Copilot is solid. Cursor is better on large projects because of full codebase indexing, but the difference is modest for most autocomplete use cases.
On agent capabilities, Cursor is clearly ahead. Copilot needed 5 manual corrections in a task where Cursor needed 2 rounds of prompting. For developers whose workflow depends on multi-file agentic tasks, Cursor justifies the extra $20/month over Copilot Pro.
The decision: Copilot for cross-IDE flexibility, teams with mixed editors, or the lowest cost with solid autocomplete. Cursor for developers who use agent mode as part of their daily workflow.
Cursor vs Lovable (Pro at $25/month)
These are different categories. Lovable is for non-developers who want to build software: it generates full React applications from plain English, deploys them automatically, and handles the database. No coding knowledge required.
Cursor is for developers who want to write code faster. It assumes you can read and review the output.
If you are deciding between Cursor and Lovable, the question is whether you are a developer. If you cannot read code, Cursor will not help you — Lovable and Bolt are the right starting points. Some developers use Lovable to generate a working MVP quickly and then use Cursor to extend and refine it. That combination is practical for building fast on greenfield projects.
Who should use Cursor — and who should not
Use Cursor if you write code professionally at least 3-4 hours per day on projects complex enough to involve multiple files, modules, and systems. At that intensity of use, agent mode and full codebase context save real time. At that level of use, Premium at $30/month is easy to justify if it saves even a couple of hours per week.
Use Cursor if you are already on VS Code and want your AI assistance to understand your full codebase rather than just the current file. The improvement over a plugin like Copilot is meaningful on large projects with established patterns.
Do not use Cursor if you are learning to code. Cursor generates code you must review, understand, and debug. Without that ability, you will get stuck every time the agent makes an error — and it will make errors. For people learning to code: start with Lovable or Bolt to build things without understanding the code, and use Claude or ChatGPT as a learning companion to explain concepts and trace errors. When you can read code fluently in your chosen language, Cursor becomes a useful acceleration tool. Before that point, the output is more confusing than helpful.
Do not use Cursor if most of your work depends on Claude or GPT. Those models now cost extra on top of every Cursor plan. A tool that includes them in the subscription price may cost you less.
Do not use Cursor if you code casually. Weekend projects, occasional scripts, light automation: GitHub Copilot Pro at $10/month is the better fit at that level of use. You will not use agent mode often enough to justify paying three times as much, and Cursor Plus at $8 does not include the coding features that make Cursor worth using.
Do not use Cursor if your team works across multiple IDEs. Cursor is its own VS Code-based editor. If team members use IntelliJ, Visual Studio, or other editors, GitHub Copilot covers all of them.
Do not use Cursor if your organisation has strict code security requirements. Code is processed by AI model providers, including xAI and, if you use them, Anthropic, OpenAI and Google. Cloud agents can run on machines you manage, but the models themselves are not self-hosted. If your codebase contains sensitive or regulated data, verify this is acceptable with your security team before adopting Cursor at an organisational level.
Cursor
The AI code editor built for professional developers.
Claude
The AI assistant that thinks carefully before answering.
ChatGPT
The most recognised AI assistant, built by OpenAI.
Lovable
Build real web apps by describing what you want.
Bolt
Build and run web apps directly in your browser.
Ready to try Cursor?
Free plan (limited). Plus $8/month (Grok only). Premium $30/month. Super $100, Ultra $200. Teams from $30/user/month.
Frequently Asked Questions
Continue reading
