Cursor Review

Since spring, three things changed for anyone weighing Cursor, and two of them change the buying decision. SpaceX agreed to buy Cursor's parent company for $60 billion. Version 3.11 shipped side chats, which let you run a second agent conversation without stopping the first. And the Teams plan split into two tiers with a real price gap between them. The rating moves from 4.5 to 4.4, and the half point is about pricing complexity and ownership questions, not the product getting worse.

The one-sentence calls: solo devs should buy Pro at $20 a month and keep going. Team leads should default to Teams Standard and promote only their heaviest agent users to Premium. Enterprise buyers now have a new line on the vendor-risk checklist, because the parent company is about to be SpaceX. What has not changed through any of this is the reason to pay: the Tab model predicts your next edit, not your next token, and that is a different mechanism from autocomplete.

What's new since May 2026

On June 16, 2026, SpaceX agreed to buy Anysphere, the company behind Cursor, for $60 billion in all-stock, with the deal expected to close in Q3 (CNBC corroborates the terms). It landed days after SpaceX's own record IPO, and against roughly $4 billion in annualized revenue per TechCrunch, an all-stock $60 billion reads as a bet on the category more than on current cash flow. SpaceX had already merged with Elon Musk's xAI earlier in the year, so the eventual owner is effectively the Grok stack. Here is what did not change on June 16: the editor on your machine. Multi-model access to Claude and GPT is confirmed through close, and nothing about your keystrokes shifted. For a solo developer the deal is a headline, not a reason to switch. For a team or enterprise, the one real forward risk is the post-close model lineup, which is unannounced. That is a due-diligence question, not a present defect.

Version 3.11 landed on July 10 with the feature that actually reshapes a working day: side chats, per the Cursor changelog. Start one with /side, /btw, or the plus button and you get a parallel, durable agent conversation that runs alongside your main thread instead of resetting it. Picture a two-hour refactor. The main agent is grinding through call-site changes across the repo, and you hit a question you would normally derail the session to ask. Fire a side chat, get the answer, then at-mention that side chat to pull its context back into the main thread. The long refactor never stops. Before 3.11, that tangent meant either interrupting the main agent or losing the thread you were on. Transcript search is the quieter half of the release. Hit Cmd+K from the Agents Window and Cursor searches a local index of past agent conversations that scales to thousands of them, so the "I built something like this three weeks ago" moment stops being a scroll. Cmd+F still searches within a single conversation. The release also redesigned the project and repo pickers and added cloud-agent hooks (beforeSubmitPrompt, afterAgentResponse, afterAgentThought).

Teams pricing split into Standard and Premium on July 1, and the gap is wide: Premium runs three times Standard's seat price for five times the included usage. That is an allocation decision, not a formality, and the tier-by-tier math lives in the Cursor pricing guide and the Cursor vs Copilot Teams pricing comparison. One more shipment worth a line: an iOS app that manages cloud agents from your phone, handy for checking on a long-running job away from the desk.

What "next edit" actually means

Ordinary completion models, including the one inside GitHub Copilot's classic inline mode, answer one question: given the cursor position, what characters come next. Cursor's Tab model answers a different one: given the change you just made, where do you go next and what do you type there. Rename a struct field and Tab will queue the call-site fixes down the file and let you cycle through them with Tab, Tab, Tab. That is not a longer autocomplete. It is a diff predictor trained on edit sequences, and the practical result is that it tracks an in-progress refactor instead of guessing a line in isolation.

The accuracy is not uniform, and the reason is mechanical. On TypeScript the model has type information to constrain the next edit, so its call-site predictions during a rename were right far more often than wrong in our use. On untyped Python the same feature degraded visibly, because the constraint that makes the prediction cheap is gone. If most of your work is dynamic and untyped, discount the headline feature accordingly. That is the single biggest variable in whether Cursor earns its price for you.

Cmd+K and Composer: the same idea at two scales

Cmd+K is an in-file instruction. Select code, describe the change, get a diff in place, accept or reject. It beats pasting into a chat panel for one concrete reason: the model already has the file and selection as context, so you spend zero turns re-establishing what you are talking about. Composer is the same primitive across many files at once: one instruction, a set of diffs, every one shown before write.

Composer's failure mode is worth naming precisely, because it is not random. An incorrect edit in the first file becomes context for the second, so a single wrong assumption compounds down the change set before any test runs. The discipline that works: keep Composer changes small enough to read every diff, and never let it touch more files than you are willing to review in one sitting. Used that way it handles multi-file refactors that a chat-window tool structurally cannot, because a chat window has no mechanism to apply and reconcile edits across files atomically.

Where the mechanism breaks

Two places, both predictable.

The codebase index. Cursor builds an embedding index so chat and Composer can pull project-wide context. Past roughly 50k files that index lags, and project-aware answers slow and thin out with it. This is the structural ceiling: the feature that makes Cursor smart about your code is exactly the feature that does not scale linearly with repo size. On a large monorepo the per-file experience stays good while the codebase-wide experience does not.

The included usage. Cursor's plans bundle a set amount of frontier-model usage and then bill on-demand in arrears (Pro is $20 a month as of the July 11, 2026 pricing page). The behavior to plan around has not changed: lean on chat and Composer all day and you consume the included allowance, after which you either pay on-demand or drop to slower models mid-task. You feel the model downgrade in the latency of the next completion. Budget for it or cap your Composer use.

What you give up by switching: nothing

Cursor is a VS Code fork, not a lookalike. Extensions, keybindings, and settings import on first launch and behave identically because it is the same editor underneath. The switching cost that normally blocks editor migrations does not exist here. That is why the recommendation is unusually clean: the downside of trying Cursor is a config import, not a tooling rebuild.

Pricing

Six tiers as of July 2026, which is itself part of the candid con. Plan selection is now a decision worth ten minutes, not a default.

Plan	Monthly	Annual	Best for	Source
Hobby	Free	Free	Trying it out	cursor.com/pricing
Pro	$20 / user	not published	Solo daily driver	cursor.com/pricing
Pro+	$60 / user	not published	Heavy solo agent use	cursor.com/pricing
Ultra	$200 / user	not published	Agent power users	cursor.com/pricing
Teams Standard	$40 / user	$32 / user	The team default	Teams pricing post
Teams Premium	$120 / user	$96 / user	The one or two heavy agent users	Teams pricing post
Enterprise	Custom	Custom	Invoicing, pooled usage, security review	cursor.com/pricing

Monthly rates were fetched from cursor.com/pricing on July 11, 2026; the Teams annual rates come from Cursor's Teams pricing post. Individual annual pricing for Pro, Pro+, and Ultra is not published on the live page as of that date. To check the current numbers yourself, start on Cursor's pricing page.

The verdict

Rating 4.4 out of 5. The half point below last quarter's 4.5 is pricing complexity plus ownership uncertainty, not a product regression. If anything, 3.11 side chats made the daily experience better. The rating moves on what changed in the editor, not on acquisition headlines.

Solo dev: buy. Pro at $20 a month on monthly billing is a low-stakes bet with no annual lock-in, and the Tab model earns it back in recovered edit time inside the first week. Confirm two things before you start: that you are on 3.11 for side chats, and at minimum on 3.0, which patched the two DuneSlide RCE flaws (CVE-2026-50548 and CVE-2026-50549, both CVSS 9.8). Any 2.x install is still exposed until you update. The acquisition changes nothing about your keystrokes.

Team lead: Teams Standard at $32 a user per month on annual billing is the default. Do not put the whole team on Premium. Watch the usage dashboard for a week or two, find the one or two people who live in agents all day, and promote only them to Premium at $96 a user. Paying the 3x seat premium across everyone to cover two heavy users is the most common way teams overspend here. Let the usage dashboard, not a guess about who codes the most, decide who gets promoted.

Enterprise: run the acquisition through your vendor-risk checklist before you standardize on Cursor. Data residency, IP ownership, and post-close model access all matter more when the parent is SpaceX and, through xAI, the Grok stack. This is a new due-diligence step, not a deal-breaker. Pin a version floor of 3.0 or later so no one on the team is running a build that predates that security patch.

The reason to pay has not moved. Write code most days on a typed language and a normally-sized repo, and Cursor turns a refactor into a sequence of confirmations instead of manual edits. It flips under two conditions. A 50k-plus-file monorepo, where the index lag erodes the project-aware features and a lighter editor plus a separate model may serve you better (the trade-offs are laid out in Claude Code vs Cursor). Or an org that cannot route source through a third-party editor, where the question is moot regardless. Outside those two cases, this is the editor to use.

Import a VS Code profile and start on Cursor's pricing page so the only variable you are evaluating is the AI.