D
DevToolsReview

Cursor Review 2026: Still Worth It After the Grok Repricing?

Our Cursor review, based on its docs, pricing and what users report. Who the $30 Premium plan suits, and when Claude or GPT at API rates makes it poor value.

DR

DevTools Review

· Updated November 7, 2026
Cursor
Pricing checked Nov 7, 2026· 1 logged

This review is based on Cursor’s documentation, pricing, changelogs and public user reports; we have not used it ourselves on production code. It sets out what Cursor is, what it is not, and who should be using it.

Get told when a price changes

We re-verify all 12 tools. You hear from us only when something actually moved.

What Is Cursor, Exactly?

Cursor is a fork of VS Code rebuilt around AI-native workflows. That means you get the entire VS Code ecosystem — extensions, keybindings, themes, settings sync — with a deeply integrated AI layer on top. It is not a plugin. The AI features are woven into the editor at a fundamental level: the tab completion engine, the inline editing system, the multi-file Composer, and the chat sidebar all share context about your project.

The team behind Cursor (Anysphere) has been aggressive about shipping. Over its history, they have added Agent mode for autonomous task execution, background indexing improvements, support for multiple AI models including Claude 3.5 Sonnet, GPT-4o, and their own fine-tuned models, and a steady stream of quality-of-life improvements.

If you are currently using VS Code, the migration is trivial. Cursor can import your extensions, settings, and keybindings from VS Code. For a step-by-step walkthrough, see our Cursor setup guide.

Key Features: What Actually Matters

Tab Completion That Predicts Your Intent

This is the feature that sells Cursor in the first five minutes. Cursor’s tab completion does not just finish the current line — it predicts the next several lines based on what you are doing.

Here is the kind of case it is built for: typing the signature of a PUT handler for a new API endpoint and having Cursor suggest the whole function body, drawing on validation schemas, database calls and error-handling conventions from elsewhere in the codebase.

How useful the suggestions are will vary by language and context. In a well-typed project, there is more information for the model to work with; with languages that carry less type information, such as vanilla JavaScript or Ruby, you should expect to review more carefully.

Cursor has invested heavily in making the completion engine feel instant, and low latency is a core part of its design.

Composer Mode: Multi-File Editing That Works

Composer is where Cursor separates itself from tools that just do inline completion. You describe a change in natural language, and Composer implements it across however many files are needed, showing you a diff for each one before you accept.

A representative task is adding internationalization to a React dashboard: “Add i18n support using react-intl. Extract all hardcoded English strings from the components in src/components/dashboard/ into a messages file. Create a Spanish translation file with placeholder translations.” Composer is designed to read the components, create the messages files, update each component to use FormattedMessage or useIntl, and add the IntlProvider wrapper. As with any generated change, expect to review each diff and fix the occasional miss, such as a string inside a template literal.

Composer should work best when the task is well-defined and the codebase has consistent patterns for it to follow. It is likely to struggle more with ambiguous requests like “make this code better” or tasks that require creative architectural decisions. It is a tool for execution, not design.

Agent Mode: Autonomous Task Execution

Agent mode takes Composer further by giving Cursor the ability to run terminal commands, read command output, and iterate on its own work. You describe a task and Agent mode plans it, executes it, runs tests, reads errors, and fixes them — looping until the task is done or it gets stuck.

A good fit is setting up a test suite for a utility library that has none: the agent can create a Jest configuration, write tests for the main functions, run them, read the failures, and fix what it can. Generated tests tend to be straightforward happy-path tests, so expect to add edge cases yourself.

Agent mode is not reliable enough to trust unsupervised. A commonly reported failure is looping, for example repeatedly adding and removing the same type assertion to fix a compilation error. Our advice: use Agent mode for well-scoped tasks, watch it work, and intervene early if it starts looping.

Codebase Awareness and Chat

Cursor indexes your entire project and uses that context in chat conversations. This is not just “search for relevant files” — it builds a semantic understanding of your codebase that you can query conversationally.

A question like “How does our authentication middleware chain work, and where does the JWT validation happen?” is what the index is for: Cursor can pull in the middleware stack, the auth middleware, the JWT utility module and the user model, and summarize them with file references. That is the kind of question that would otherwise take a new team member a long time to answer by reading code.

The chat is also useful for explaining unfamiliar code, such as a dense piece of RxJS logic: ask “what does this do in plain English?” and it can walk through the chained operators.

Model Flexibility

Cursor still offers a wide choice of models, but they’re no longer treated equally. Paid plans include one weekly allowance for Cursor’s own models: Grok 4.7, 4.6 and 4.5, plus Composer 2.5. Claude, GPT and Gemini sit outside that allowance, and on Premium and above they’re paid for at API list price from prepaid credit. Plus and Free don’t include them at all.

The ability to switch models mid-conversation is genuinely useful. A sensible pattern is to start complex debugging sessions with a stronger reasoning model, then switch to a faster model for implementation once you know what to do.

Pricing

Cursor repriced in October 2026, following the SpaceX/xAI acquisition of Anysphere. The old $20/month Pro plan (and the $60 Pro+ and $40/user Teams plans) are closed to new customers, though existing subscribers keep them until they switch. The current lineup:

Free: Limited usage and full access to the editor. Enough to evaluate the tool, but not enough for daily professional use.

Plus ($8/month): Grok models only, drawn from a shared usage pool, bundled with X Premium perks. Cheap, but if you want Claude or GPT in Cursor, this is not your plan.

Premium ($30/month): The real working tier — 4x usage, cloud agents, and Bugbot. This is what replaces the old $20 Pro for individual developers. The catch: third-party models (Claude, GPT, Gemini) are billed separately at API list price on top of the $30. Your real monthly cost on Premium will depend heavily on which models you use and how much.

Super ($100/month) and Ultra ($200/month): 15x and 50x usage respectively, for heavy Agent mode users.

Teams (from $30/user/month): Centralized billing, admin controls, SSO, and enforced privacy mode. The privacy mode is important — it ensures no code is stored or used for training. Enterprise pricing is custom.

The pricing is still defensible for the productivity gain, but it is no longer simple. Heavy Agent mode usage burns through your allocation quickly, and with third-party models billed at API rates on top of the subscription, an Agent session on Claude now costs you real money rather than just quota. For a full breakdown of each tier, see our complete Cursor pricing guide. Plan accordingly.

What Cursor users report

Read Nov 7, 2026 on Cursor's community forum and Hacker News. These are individual, self-selected posts, not a survey, and unhappy users post more often. This round doesn't include Reddit.

  • Claude and GPT now cost extra

    Complaint

    Since October, third-party models on new plans are paid for at API list price on top of the subscription. One user says Opus burns through usage so fast they rarely use it in Cursor, and is weighing Claude Code on cost.

    Cursor's announcement, Oct 12, 2026 · Hacker News comment, Nov 6, 2026

  • Weekly limits divide opinion

    Mixed

    Cursor says a weekly refresh stops one heavy day from using up the month. A Pro subscriber argues the reverse: weekly caps penalize busy weeks and give less control for the same money.

    Forum feedback post, Nov 2, 2026

  • Grok models get credit on price

    Praise

    Users who stay on Cursor's own models are happier. One calls Cursor with Grok the best budget option for routine tool use, and another settled on the roughly $200 bundle after trying other setups.

    Hacker News comment, Oct 25, 2026 · Hacker News comment, Nov 4, 2026

  • Usage screens can confuse

    Complaint

    Before the October repricing, one user disputed how Grok usage was labeled and charged, and left after saying support answers conflicted. Staff called one label a launch-day glitch and another a display issue that didn't affect billing.

    Forum thread, Jul 9, 2026

Pros and Cons

What We Love

  • Tab completion is among the strongest in the category, with fast, context-aware, multi-line predictions.
  • Composer mode is built around multi-file edits. The diff-based approval flow gives you control without sacrificing speed.
  • Seamless VS Code migration. Your extensions, themes, and muscle memory all transfer. The switching cost is near zero.
  • Model choice lets you optimize for speed versus reasoning depth depending on the task.
  • Active development cadence. The team ships meaningful updates frequently. The changelog shows steady improvement.

What Frustrates Us

  • Import hallucinations remain a recurring issue. Users report that Cursor sometimes invents packages that do not exist or uses import paths from different frameworks. You learn to watch for it.
  • Context window limits are invisible and confusing. When a Composer session hits the context limit, it starts losing track of earlier files. There is no clear indicator that this is happening — the quality just degrades. Cursor should surface this more transparently.
  • Usage costs are hard to predict. Under the old plans, the distinction between “fast” and “slow” requests was opaque. The October 2026 repricing replaced that with usage multipliers plus separate API-rate billing for Claude, GPT, and Gemini — which makes the monthly bill even harder to forecast.
  • Memory across sessions is limited. Cursor does not remember what you discussed yesterday. You can mitigate this with .cursorrules files, but native session memory would be a significant improvement.
  • Marketplace risk is real. On October 30, 2026, researchers reported backdoored builds of the Claude Code extension on the Cursor Marketplace, versions 2.1.312 and 2.1.313. Cursor removed both. If you had either installed, follow that advisory, because uninstalling alone does not remove the backdoor.
  • Electron resource usage is real. Users report that on machines with 8GB RAM, Cursor can get sluggish during heavy indexing or long Composer sessions.

Cursor vs. the Competition

Compared to GitHub Copilot, Cursor offers dramatically better multi-file editing and codebase awareness. Copilot’s inline completions are competitive on single lines, but Cursor’s Tab predictions across multiple lines are in a different league. If you only need basic autocomplete in VS Code, Copilot is cheaper and simpler — Copilot Pro at $10/month is a third of Cursor Premium’s $30, before Cursor’s separate third-party model charges. If you want AI-powered editing workflows, Cursor is the clear winner. For a detailed breakdown, read our Cursor vs Copilot comparison.

Compared to Windsurf, Cursor’s editor is more polished and stable. Windsurf’s Cascade feature is conceptually similar to Cursor’s Agent mode but Cursor is generally regarded as the more polished of the two. Windsurf has a more generous free tier, which matters if you are evaluating tools on a budget. See our Cursor vs Windsurf comparison for the full breakdown.

Compared to Claude Code, Cursor is a fundamentally different experience. Claude Code is an agent rather than an editor: it runs in the terminal, as an extension inside VS Code (and Cursor itself), or in a desktop app, and it has no autocomplete, which makes it strong for large tasks but no help while you type. If you want AI integrated into your editing flow, Cursor wins. If you want a thinking partner for hard problems, Claude Code wins. Many developers use both.

Who Should Use Cursor

Cursor is the right choice if you:

  • Write code for multiple hours every day and want to accelerate your output
  • Work on medium-to-large codebases where codebase awareness pays dividends
  • Are currently using VS Code and want AI integration without learning a new editor
  • Do frequent refactoring, feature additions, or multi-file changes
  • Are comfortable reviewing AI suggestions rather than accepting blindly

Cursor is probably not for you if you:

  • Only code occasionally or do light scripting
  • Prefer minimal, distraction-free editors like Vim or Emacs (though Cursor has Vim keybinding support)
  • Are on a very strict budget and the free tier’s limits would frustrate you
  • Work in a highly regulated environment that prohibits sending any code to external APIs (Tabnine used to be the default answer here, but it is no longer sold to new customers following its acquisition by Tricentis)

The Bottom Line

Cursor remains our default recommendation for one kind of developer: someone who wants AI built into a VS Code-style editor and is comfortable working mostly on Cursor’s own models. Its tab completion is designed to save time on every function you write. Composer mode turns multi-file changes from a chore into a conversation. Agent mode, while not yet reliable enough to run unsupervised, handles well-scoped tasks impressively. The rough edges — import hallucinations, context limits, resource usage — are real but manageable.

If Claude or GPT is the reason you’re looking at Cursor, price that usage first. You may get better value from Claude Code or Copilot. The learning curve is small either way, because Cursor is built on VS Code.

DR

Written by the DevTools Review team

We research AI coding tools from vendor documentation, pricing pages, changelogs and public user reports, and re-check prices against vendors' own pages. We don't claim hands-on testing we haven't done. How we work.

Change tracker

Get told when a price changes

We re-check what all 12 tools cost against each vendor's own pricing page. When something moves — a price, a free tier, a limit — you get an email. When nothing moves, you get nothing.

Confirmation required. Unsubscribe in one click, from any email.