Cursor scored 68/100 in multi-stage benchmark as layered revisions break agent performance

A structured three-stage testing gauntlet reveals Cursor's strengths in IDE familiarity and its critical failures when handling layered prompt revisions and offline functionality.

The verdict up front

Cursor remains the default choice for experienced developers who want an AI-augmented VS Code environment, but it is a poor fit for non-technical builders or those expecting autonomous, multi-turn execution. In a structured 100-point benchmark by developer Ilyas Elaissi, Cursor scored 68/100, dragged down by a 13/25 score in AI agent effectiveness. While its interface is highly intuitive for anyone familiar with VS Code, its agent struggles to maintain state and follow instructions during layered revisions, ultimately breaking layouts and missing explicit requirements like offline mode. Skip Cursor if you cannot write code to fix its generation errors. Use it if you want surgical, developer-guided completions.

Methodology

This review evaluates Cursor based on a structured benchmark published by developer Ilyas Elaissi on dev.to. The testing methodology ran Cursor through a three-stage gauntlet: a simple build, a complex Reddit-style MVP (requiring authentication, offline mode, and threading), and multiple rounds of layered revisions (adding a light/dark toggle, a chatbot, and executing a full layout redesign). The tool was scored against a 100-point rubric divided into four 25-point categories: UX and interface, AI agent effectiveness, code export/deployment, and pricing.

v0 honest version: This review draws on the testing methodology and findings published by Ilyas Elaissi at https://dev.to/ilyas_elaissi/best-ai-for-code-top-4-tools-tested-and-ranked-3cha. Independent verification of these exact prompt-by-prompt failures is pending, and the source signal was truncated before the deployment and pricing scores were fully detailed. We supplement this with verified market pricing for Cursor as of May 2026.

What it does

An IDE built on VS Code

Cursor functions as a fork of VS Code, preserving the standard layout of a left-side file explorer, center editor, and right-side AI chat panel. This design ensures that developers experience zero learning curve when transitioning from a traditional setup.

The multi-stage prompt gauntlet

The benchmark tested Cursor's ability to generate a complex Reddit-style MVP. The prompt explicitly demanded authentication, offline mode, and message threading.

Handling layered revisions

After the initial generation, the benchmark introduced sequential modifications: implementing a light/dark mode toggle, integrating a chatbot, and requesting a complete layout redesign while preserving existing backend functionality.

What's interesting and what's not

The breakdown under revision pressure

The most significant finding is Cursor's rapid degradation when handling cumulative instructions. While the initial simple app was functional, though visually primitive, the complex build failed to implement the requested offline mode entirely. More critically, when subjected to layered revisions, the agent began to lose track of state. The light/dark toggle left several UI components permanently dark, and the final redesign request completely broke the application layout. This indicates that Cursor's context window management or instruction-following weights struggle with multi-turn, stateful modifications.

Familiarity vs. accessibility

Cursor's high UX score (19/25) is entirely dependent on the user's background. For seasoned engineers, the dense VS Code interface is a massive benefit. However, for non-technical founders, this density introduces immediate friction. It is not a no-code tool; it is an editor that expects you to know how to navigate a file tree and debug manual deployment configurations.

Manual deployment friction

Unlike newer generation-to-deployment platforms, Cursor does not offer native, one-click hosting. Deploying the generated code requires manual setup, such as installing and configuring the Netlify extension. For developers, this is standard; for rapid prototyping, it is an unnecessary speed bump.

Pricing

Pricing verified as of May 2026:

• Hobby Tier: Free. Includes 20 monthly fast premium model uses, 50 slow uses, and 2,000 completions.
• Pro Tier: $20 per month. Includes 500 fast premium uses per month, unlimited slow uses, and unlimited completions.
• Business Tier: $40 per user per month. Adds centralized billing, admin controls, and privacy mode by default.

Verdict

Cursor is a highly capable developer's companion that fails as an autonomous software engineer. Its 68/100 benchmark score reflects this duality: it excels at providing a familiar, powerful environment for manual coding (19/25 UX) but falters under the cognitive load of complex, multi-turn agentic tasks (13/25 AI effectiveness). If you are an experienced developer who can step in and manually fix broken layouts or write missing offline sync logic, Cursor is an excellent choice. If you are a non-technical founder looking to build and deploy an MVP without touching code, skip Cursor and look toward platforms with stronger autonomous agent capabilities and native hosting.

What we'd test next

To build on Elaissi's findings, we want to run a controlled test measuring token consumption and context degradation over 10 sequential revision rounds. Specifically, we need to benchmark how Cursor's Composer feature handles file-to-file dependency updates when refactoring a database schema versus a purely visual CSS change. We also plan to test its performance using alternative underlying models, such as Claude 3.5 Sonnet versus GPT-4o, to isolate whether the instruction-following failures stem from Cursor's system prompts or the LLM itself.

The investor read

Cursor's performance in this benchmark highlights a critical bottleneck in the AI developer tool category: the transition from autocomplete to autonomous agent. While Cursor has captured massive developer mindshare by piggybacking on the VS Code ecosystem, its poor score in agent effectiveness (13/25) shows it remains an incremental productivity booster rather than a replacement for engineering headcount. For investors, this suggests that the 'wrapper' IDE model is highly vulnerable to platforms building native, agent-first architectures from the ground up. The enterprise spend will flow to tools that can reliably execute multi-turn refactoring without human intervention, a capability Cursor has yet to prove.