I switched to Cursor full-time in October 2024, quit it twice, came back both times, and I now spend roughly six hours a day inside it. The June 2025 credit-billing change made me seriously consider going back to VS Code plus Copilot for a week. I didn't. This review is what I would have wanted to read before that first switch, and what I would tell any developer asking me what Cursor costs now and whether to pay it.
I paid for Pro, then Pro+, then briefly Ultra during a heavy refactor month, then back to Pro. I've watched the pricing shift twice and the Composer model evolve through three major versions. What follows is what actually holds up after real use.
What Cursor is in 2026
Cursor is an AI-first code editor built as a VS Code fork by Anysphere, now a SpaceX company, and as of mid-2026 it has passed 2 million paid users and roughly $2 billion in annualized revenue, per reporting from The Information in April 2026. It looks like VS Code because it is VS Code with the AI features baked into the core editor instead of bolted on as an extension.
Cursor is now owned by SpaceX. The deal was announced on June 16, 2026 at $60 billion in all stock, reported as the largest acquisition of a venture-backed startup on record, and it closed on August 14, 2026. Cursor announced it themselves under the title Cursor is now a part of SpaceX, with the line that it completes the acquisition process that started in April when they announced a model training partnership.
This page said the opposite for most of the last month. It stated that as of August 13 the deal had not closed and that completion was expected by the end of August, which was accurate on the day it was written and wrong from the following morning. I re-checked on September 9 and found Cursor's own announcement dated August 14, so the review carried the wrong owner for twenty-six days.
What comes with it is compute. Cursor's announcement says the acquisition gives them access to the largest fleet of GPUs in the world, and frames that as the route to more capable models at lower cost. It follows SpaceX's merger with xAI in February, which is why Grok sits alongside Composer as a first-party Cursor model. Their announcement references Grok 4.6, released two days before it, so the version in the tables below has already moved on.
For most solo developers this changes nothing about the editor today. If you work somewhere with a view on which companies your source code gets sent to, that question now has a definite answer rather than a pending one, and it is worth asking before you standardise a team on Cursor.
The product identity shifted through 2025. Cursor started as "autocomplete on steroids" and matured into a full agentic development environment. In the current 3.0 release, you can chat with your entire codebase, edit dozens of files in one prompt, run background agents that finish tasks while you work on something else, and use MCP servers to connect Cursor to your database, browser, or internal tools.
Anysphere's own model, Composer 2.5, launched in April 2026 and now handles most of Cursor's Agent-mode work. That matters because Composer is trained specifically for coding tasks and runs faster than frontier general-purpose models on the same benchmarks.
Cursor 3.0 and what's new
Cursor 3.0 shipped in March 2026 and introduced four things that changed how I use the editor daily.
The Agents Window lets you spin up multiple background agents on different tasks, monitor them in a side panel, and merge their work back into your main branch. I run up to four agents at once during heavy weeks: one refactoring a component, one writing tests, one investigating a bug, one summarizing PR comments.
Design Mode takes a Figma link or a screenshot and generates the corresponding React/Tailwind code. It's not perfect (spacing is off maybe 30 percent of the time), but for prototyping a new UI section it saves an hour of translating design specs to props.
The /worktree command spawns a git worktree scoped to a specific task, so you can work on three branches simultaneously without stashing. This is the kind of quiet improvement I didn't know I wanted until I had it.
Composer 2.5 replaced the earlier Composer model and now handles most agent-mode requests unless you manually override. In my testing it was faster and cheaper than the frontier models I compared it against, and usually good enough for well-scoped tasks. The numbers behind that are in the next section, with the caveat that I measured them against models which have since been superseded.
The features I use daily
Cursor has too many features to review each one at length. These are the ones I open the editor for.
Tab completion is still the best in the industry and the reason many developers stay after trying it. It predicts multi-line completions with context from your open files, and roughly 40 percent of my code now comes from accepting Tab suggestions without modification. Tab is unlimited on every paid plan.
Cmd+K opens an inline prompt over the current selection. I use it for renames, quick refactors, adding a docstring, or converting a function from callback to async/await. Cmd+K is my most-used feature because it stays in flow with normal editing.
Chat (Cmd+L) opens a sidebar conversation scoped to your codebase. Ask "where is the auth middleware defined" and it finds the file, opens it in a preview, and explains the relevant logic. Chat routed through Cursor's own models is cheap enough that I use it about as freely as I'd use Google, though it is no longer free the way it was a year ago.
Composer is the multi-file editor. Ask "add rate limiting to every route in /api/v1" and Composer edits every file in one atomic diff you can review and accept. This is the feature that put Cursor ahead of Copilot in 2024 and remains the moat.
Agent mode is Composer with the ability to run terminal commands, read output, and iterate. I use Agent for tasks like "run the test suite, find the failing test, fix it, run again until green."
Cloud Agents, which you may still see called Background Agents, run Agent tasks in the cloud on separate infrastructure. You can spin one up on your phone during a walk, come back to your laptop 20 minutes later, and merge the completed work. They draw more usage than local Agent runs because they use a longer-context model, and they are not available on the Plus tier at all.
MCP servers extend Cursor to any external tool that speaks the Model Context Protocol. I've hooked Cursor to my Postgres database (so the AI can query real schema when writing migrations), my Sentry account (so it can pull recent errors), and Linear (so it can create issues from code comments).
Rules (via a .cursorrules file or Project Rules in settings) inject persistent instructions into every AI request in a repo. My .cursorrules for a Next.js SaaS is 40 lines telling Cursor about our conventions, folder structure, and banned patterns.
Hooks let you run shell commands on events like pre-prompt or post-response. Useful for auto-formatting or logging AI interactions to a file.
Plan Mode is a newer 3.0 feature. Cursor drafts a step-by-step plan before making changes, and you approve or edit each step before it runs. It's the safest way to use Agent mode on production code.
Composer 2.5: the in-house model and benchmarks
Composer 2.5 is Cursor's proprietary coding model, launched April 15, 2026 per the Cursor blog announcement. It scored 79.8 percent on the SWE-bench Multilingual benchmark, effectively tied with Claude Opus 4.7 (80.1 percent) and ahead of GPT-5 (76.4 percent) on the same test.
Everything in this section was measured in the spring of 2026 and the comparison models have moved on since. Cursor's own model list now offers Claude Opus 5.5, GPT-5.6 in three variants, Gemini 4 Argon and Grok 4.7, none of which existed when these benchmarks were run. Composer 2.5 is still the current version of Cursor's model, so the figures below describe it accurately. What they no longer tell you is how it stands against today's frontier models, and I am not going to extrapolate a ranking I have not measured.
The bigger deal was speed. Composer 2.5 ran at roughly 200 tokens per second on Cursor's infrastructure against about 80 to 100 for Opus 4.7 through the API, which turned a 90 second multi-file refactor into 35 to 40 seconds. That gap is the reason Composer became my default and it has not closed in daily use since.
Cost per request was lower too, $0.04 to $0.08 per Agent action against $0.15 to $0.25 for Opus 4.7. Those per-request figures belong to the legacy billing model, where third-party models drew down a dollar pool. On the new plans Cursor's own models come out of the weekly pool instead and third-party models are billed as prepaid credit at list price, so the shape of the comparison has changed even though the direction has not: Cursor's own model is still the cheap default and the frontier models are still what you reach for on hard problems.
Is Composer 2.5 as smart as a frontier model on the hardest tasks? No, not always. On genuinely novel architecture decisions or subtle debugging, the big models still edge ahead. But it is close enough that for most coding work Composer wins on speed per dollar, which is also why Plus at $8 is a reasonable plan despite having nothing else in it.
Cursor pricing 2026 explained
Every plan name in the previous version of this review is now a legacy plan. If you read this article before November and went to buy what it recommended, you could not have bought it. Cursor is now sold as part of what its own docs call The X Subscription, one subscription covering Grok, Cursor and X.
These are the plans a new customer sees.
| Plan | Monthly | Included usage | Third-party models |
|---|---|---|---|
| Free | $0 | Limited | Not available |
| Plus | $8 | Base | Not available |
| Premium | $30 | 4x Plus | API list price, from prepaid credit |
| Super | $100 | 15x Plus | API list price, from prepaid credit |
| Ultra | $200 | 50x Plus | API list price, from prepaid credit |
| Teams | $30, $100 or $200 per seat | Matches the seat's tier | Same as the matching tier |
| Enterprise | Custom | Pooled | SCIM, audit logs, invoice billing |
Read off Cursor's models and pricing docs on November 4, 2026. Annual billing is $80 for Plus, $300 for Premium, $1,000 for Super and $2,000 for Ultra.
The headline reads like a price cut. Cursor's cheapest paid plan went from $20 to $8. Read the right-hand column before celebrating.
The $8 plan cannot run Claude, GPT or Gemini
On Free and Plus, third-party models are not available. Not metered, not rationed, not expensive. Not available.
What Plus gives you is Cursor's own models, which the docs list as Grok 4.7, Grok 4.6, Grok 4.5 and Composer 2.5, and it runs them at fixed settings: Fast off, effort medium, and Grok 4.7 held to its 256k context window. No Auto. No Cloud Agents.
So if you came to Cursor to point Claude at your codebase, your entry price is not $8. It is Premium at $30, where third-party models become available at the provider's API list price, paid from prepaid credit you buy on top of the subscription.
Set that against legacy Pro at $20, which included $20 of third-party usage in the subscription. The comparable plan now costs half again as much and bundles none of it. That is a price rise wearing a price cut's clothes, and it is the single most important thing in this review.
If you already pay for Cursor, you are on a legacy plan
Cursor's help page is straightforward about this: subscribe before the change and you are on a legacy plan, which keeps working as it is with two monthly usage pools and on-demand usage. It also publishes a mapping table, which is where the cost lands.
| Legacy plan | Price | Comparable plan now | Price now |
|---|---|---|---|
| Hobby | Free | Free | $0 |
| Start (India only) | ₹649 | Plus | $8 |
| Pro | $20 | Premium | $30 |
| Pro+ | $60 | Super | $100 |
| Ultra | $200 | Ultra | $200 |
| Teams Standard | $40/user | Teams, Premium seat | $30/user |
A legacy Pro subscriber who moves pays 50 percent more. Pro+ pays 67 percent more. Teams Standard customers are the only ones who gain, dropping from $40 to $30 a seat.
And the move is one way. Cursor states that switching cancels your Cursor subscription with a prorated refund, you then pick a plan on The X Subscription, and the change is permanent. You can still move between legacy plans, Pro to Pro+ for instance, without triggering that.
If you are on legacy Pro and it still covers your month, the arithmetic says stay where you are.
Two pools became one
The earlier version of this review explained Cursor's dollar-denominated pools: Pro included $20 of third-party usage, Pro+ included $70 rather than $60, Ultra included $400. I described that as the current system. It is now the legacy system, and the distinction is not cosmetic.
New plans include one weekly pool of usage for Cursor's own models, shared across everything on the subscription: Agent in the editor, the CLI, Cloud Agents and Grok. The tiers are multiples of Plus rather than dollar amounts, and Cursor does not publish what Plus's base pool is in tokens or requests. Four times an unpublished number is as precise as anyone can be about Premium, including me.
Max Mode moved with it. The docs now say it is available only on legacy request-based plans, where it extends a model's context window beyond the default and bills at the model's API rate plus 20 percent. On a new plan that lever does not exist.
The June 2025 credit switch controversy
Before June 2025, Cursor sold "500 fast requests per month" on Pro. Requests were the unit and you could burn them without watching the meter closely. In June 2025, Anysphere replaced this with the credit system, and heavy users saw their effective monthly capacity drop by roughly 40 percent overnight.
Reddit's r/cursor pinned a megathread that ran for weeks with hundreds of complaints. The main issues were unclear per-model pricing, surprise overage bills, and the vague explanation from Cursor's team. A support account named "Sam" that turned out to be an AI bot posted responses that made the situation worse before Anysphere clarified it wasn't a human.
Anysphere responded by publishing detailed per-model credit costs, adding a spending dashboard, capping automatic overages, and adding a warning when you cross 75 percent of your pool. Cursor is not alone in this: every serious tool in the category rebuilt its billing in 2026, and none of them landed on the same unit, which I worked through in AI coding agent pricing. By September 2025, the loudest complaints had faded and most heavy users adapted. But it's still the number one complaint I hear from developers considering the switch to Cursor in 2026.
Cursor vs GitHub Copilot vs Devin Desktop (formerly Windsurf) vs Claude Code
Nobody uses only one AI coding tool in 2026. Understanding the tradeoffs helps you pick the right primary.
| Feature | Cursor Pro ($20) | Copilot Pro ($10) | Devin Desktop Pro ($20) | Claude Code (metered) |
|---|---|---|---|---|
| Editor integration | Native (VS Code fork) | VS Code / JetBrains extension | Native, AI-first editor | Terminal-based |
| Tab completion | Best-in-class, unlimited | Very good, unlimited | Good | None (not an IDE) |
| Multi-file editing | Composer (excellent) | Agent mode and Cloud Agent | Agent-driven, strong | Excellent via terminal |
| Agent mode | Yes (Local + Background) | Copilot Agents (limited) | Yes, local and cloud | Yes (headless) |
| MCP support | Full | Partial (2026 beta) | Not re-checked since the rebrand | Full |
| Best model | Composer 2.5 default | OpenAI's current flagship | Not published per plan | Anthropic's current flagship |
| Ideal for | Full-time AI-first coding | Autocomplete-focused workflow | Cursor alternative at the same price | Terminal-heavy, agent-first |
A note on that third column, because this table said something wrong for months. It used to be headed Windsurf Pro at $15, which is a product that no longer exists at a price that is no longer charged, and it sat directly above a paragraph explaining exactly that. The price is now the figure I am most confident in: $20 for Pro is what Devin's own plans page listed when I read it on August 13, alongside a free tier and Max at $200. The capability rows carry over from when the product was Windsurf, and I could not re-verify the feature names or the free quota after the rebrand because devin.ai returns rate-limit errors to automated requests. So read that column as reported rather than checked, and check the free quota yourself before you commit to it.
Copilot is the safer enterprise pick because of Microsoft's compliance story and its $10 price, though that $10 now includes $15 of metered credits rather than unlimited chat, which I unpack properly in Cursor vs GitHub Copilot. Devin Desktop was Cursor's closest direct competitor back when it was called Windsurf, and Cognition absorbing it is why both windsurf.com and codeium.com now land on devin.ai. I went through what survived that and what did not in Cursor alternatives. Claude Code (Anthropic's terminal tool) isn't an IDE at all, but it's the best agentic tool for long-running background work.
My honest ranking for daily coding in 2026: Cursor Pro first, Devin Desktop (what Windsurf became) second, Copilot Pro third for pure IDE work. Claude Code fills a different niche (see the hybrid workflow section below).
If you're earlier in this than the table assumes, my rundown of the top AI coding assistants for beginners covers the same field without the pricing math, including a breakdown of the AI coding assistant learning curve for beginners that explains why Cursor is usually the wrong first tool.
The Cursor + Claude Code hybrid workflow
The setup that nobody documents well: run Cursor as your primary IDE for interactive edits, and run Claude Code in a terminal tab for heavy agent tasks. This is what many senior developers I know settled on in early 2026, and it costs less than a single Ultra subscription.
Why hybrid? Cursor's Composer 2.5 is fast and cheap for edits inside a file or across a small file set. Claude Code, running whichever Opus or Sonnet is current, is better for tasks that run 30+ minutes autonomously: large migrations, whole-feature scaffolds, or debugging sessions that touch a dozen files. This split is also a way around the new pricing, since Claude Code bills through your Anthropic plan rather than Cursor's prepaid credit.
Here's the split I use:
Cursor handles: quick edits, refactors under 5 files, chat about the codebase, Tab completions, Design Mode UI work, small bug fixes, test-writing sessions.
Claude Code handles: multi-hour refactors, full-feature scaffolding, cross-repo changes, dependency upgrades that span 50+ files, anything I want to run overnight.
A .cursorrules snippet that helps them coexist:
When asked to make changes that would span more than 8 files
or take more than 15 minutes of continuous work, suggest running
the task in Claude Code instead and provide a clear task prompt
the user can paste into their terminal.
Never start a task that would exceed the Cursor Pro credit pool.
If unsure, ask the user to confirm.
Follow the project style guide in docs/STYLE.md.
Do not modify migration files in prisma/migrations directly.
MCP setup for the hybrid: install the same MCP servers in both tools (Postgres, Sentry, Linear, filesystem). Both Cursor and Claude Code speak MCP, so your integrations work identically. My monthly cost for the hybrid setup is about $60: Cursor Pro at $20 plus roughly $40 in Claude Code API usage.
If the Claude half of that is new to you, I wrote a separate walkthrough on using Claude AI for coding. And if $60 a month is more than you want to commit, the best AI tools under $20 breaks down what a single-subscription setup actually gets you.
Real cost calculator for 3 dev personas
Cursor's pricing pages show list prices. Real bills look different. These are estimates for a new customer buying today, which is a different exercise from the one in earlier versions of this review, because the plan that used to be the obvious answer is no longer on sale.
Persona 1: Junior developer learning Next.js at home
Codes 6 to 10 hours per week on side projects. Uses Chat and Tab constantly, rarely triggers Agent mode. Used to lean on Auto mode by default.
The Auto habit is the problem. Auto is not on Plus, so at this volume the choice is Free, or Plus at $8 for Cursor's own models with the settings fixed.
Monthly bill: $8, or $0 if the Free tier's limits hold.
Best plan: Plus at $8, on the condition that you are content learning with Grok and Composer rather than Claude. If you specifically want Claude explaining your code, you are looking at $30, and at 6 to 10 hours a week that is hard to justify against Copilot at $10.
Persona 2: Senior engineer on a 200K-LOC Next.js SaaS
Codes 40+ hours per week. Uses Composer daily for refactors, runs 2 to 4 Cloud Agents per week, and reaches for a frontier model for tricky debugging perhaps 30 times a month.
Those 30 debugging sessions decide it. Frontier models are not available below Premium, so Plus is out regardless of volume.
Monthly bill: Premium at $30, plus prepaid credit for the frontier calls. Thirty sessions at the providers' list rates is realistically $15 to $40 depending on model and context, so $45 to $70 all in. Super at $100 only makes sense once Cursor's own models stop keeping up, not because of the frontier calls.
Best plan: Premium at $30 with prepaid credit. If you are already on legacy Pro+ at $60 with its $70 pool, run the comparison before you touch anything, because switching is permanent.
Persona 3: 5-person agency team
Five developers across two projects, using Cursor daily. Two use Cloud Agents heavily for client work. Sensitive client codebases require Privacy Mode.
This is the one case where the change is straightforwardly good news.
Monthly bill: five Premium seats at $30 is $150, against $200 under the old Teams Standard pricing. Prepaid credit for the two heavy users adds perhaps $30 to $60. Total $180 to $210, down from $230 to $260.
Best plan: Teams on Premium seats. Privacy Mode is on by default, admins can lock it for the whole organisation, and you can mix Premium and Super seats rather than paying one rate for everyone. Read the Privacy Mode carve-outs first, particularly the one about Opus models with cyber safeguards off.
What Cursor genuinely nails
Tab completion after two years still feels magical. Multi-line predictions are shockingly accurate on codebases larger than 100K lines because Cursor indexes the whole repo and pulls relevant context into completions.
Composer's multi-file edits are the reason developers put up with any Cursor rough edges. Ask for "extract this into a shared utility and update every call site" and it delivers a diff you can accept in one click. Copilot's equivalent, now agent mode in the editor and its Cloud Agent rather than the retired Copilot Workspace, is closer than a year ago but still lags on precision.
Cursor's team ships fast. There's a meaningful new feature roughly every three weeks. The pace is closer to a startup than any code editor I've used.
The community-driven rules ecosystem (from .cursorrules files shared on GitHub to the awesome-cursorrules repo) means most stacks have a battle-tested config within a week of Cursor releases.
Where Cursor still frustrates
Memory issues on files above 500 lines. When Composer edits a large file, it sometimes drops the last 20 to 40 lines during the diff apply, forcing you to re-prompt. Reddit threads document this and Anysphere acknowledged it, but as of July 2026 it's not fully fixed.
Credit surprises. Even with the dashboard and 75 percent warning, I've had months where a single long Agent session ate 40 percent of my pool in one afternoon. The MAX mode surcharge in particular catches new users.
The "Sam" support bot situation left scar tissue. Even after Anysphere clarified and improved human support, some developers still don't trust the company. Rebuilding that took the whole second half of 2025.
Extension conflicts occasionally break AI features. Some VS Code extensions that hook into completion providers can degrade Tab quality until disabled. Anysphere publishes a list of known-bad extensions but it isn't exhaustive.
Windows and Linux polish still lags Mac. Not by much, but Mac users get new features first and the fewest bugs.
Who should (and shouldn't) use Cursor
Should use Cursor: full-time developers writing production code daily. Engineers who want to spend time on architecture rather than typing. Anyone doing large refactors, migrations, or feature scaffolds. Solo founders who need AI leverage to move faster. Teams that want a shared AI-editor standard.
Shouldn't use Cursor: absolute beginners who need to learn syntax the slow way (use vanilla VS Code with light Copilot at most). Enterprise environments where AI editors aren't approved. Developers whose employer restricts pasting code into external AI services (even with Privacy Mode, some legal teams say no, and the carve-outs below give them a reason). Anyone whose main requirement is Claude or GPT on a tight budget, because Copilot at $10 now reaches those models for less than Cursor's $30 Premium tier.
Verdict: what Cursor costs now, and whether to pay it
The tool is still the best of its kind for how I work. Tab completion alone earns its keep, and Composer, Agent mode, MCPs and talking to your codebase stack on top of that. None of my criticisms are about the editor.
They are about the price, and the price moved twice in eighteen months. The 2025 credit switch hurt trust and the company spent a year climbing out of it. The late 2026 restructure is a second move in the same direction, and it is cleverer: the number on the pricing page went down while the cost of the plan most developers actually need went up by half.
Where that leaves you depends on which side of the change you are on.
If you already pay for legacy Pro at $20, stay. You keep the price and the included third-party usage, and moving is a permanent one way switch to $30.
If you are buying today and want frontier models, budget $30 for Premium plus prepaid credit, and compare that honestly against Copilot at $10 before you commit. Cursor has to win on Composer, Agent mode and codebase awareness now, because it no longer wins on price.
If you are buying today and are happy inside Cursor's own models, Plus at $8 is a genuine bargain and the cheapest capable AI editor I know of. Just go in knowing that Claude, GPT and Gemini are not part of it, and that Auto and Cloud Agents are not either.
And if you run a team, this change is in your favour for once: Premium seats at $30 are cheaper than the $40 Teams Standard seats they replace.
I still write this article inside Cursor, using Composer 2.5 for structural edits and Tab for the last 5 percent of prose fixes. After 18 months of daily use, two pricing upheavals and one credit-system tantrum, I have not found a better tool for how I code. I am just no longer able to tell you it is the cheap option.
Sources
- Cursor pricing page
- Cursor models and pricing docs. New plan table, the weekly pool, Plus's fixed settings, and Max Mode being legacy only. Read November 4, 2026
- Cursor pricing and plans help page. The legacy plan mapping table, annual prices, and the statement that switching is permanent. Read November 4, 2026
- Cursor privacy and data help page. Privacy Mode defaults and the zero retention carve-outs. Read November 4, 2026
- Cursor pricing and billing docs. Legacy plan pools and Auto mode rates, checked July 31, 2026
- Introducing Cursor Start (India). July 27, 2026
- CNBC: SpaceX to acquire Cursor for $60 billion
- Cursor Composer 2.5 announcement
- Cursor 3.0 release notes
- Reddit r/cursor pricing megathread (June 2025)
- The Information: Anysphere revenue report (April 2026)
- DEV Community: Cursor vs Windsurf vs Claude Code comparison
- Awesome Cursor Rules repository
- Anthropic Claude Code documentation