A code editor built by a startup with fewer than 100 employees just hit 1 million daily active users. Stripe uses it. Figma uses it. Over 50,000 businesses have adopted it. In a market where VS Code has owned the editor space for years and JetBrains has loyal enterprise customers, Cursor somehow carved out a massive niche in under two years.
I've been trying to figure out what they're doing differently. Here's what I think is actually going on.
They Didn't Build an Extension — They Built an Editor
This is the decision that mattered most. When GitHub Copilot launched, it was a VS Code extension. When other AI coding tools showed up — Tabnine, Codeium, Sourcegraph Cody — they were all extensions too. They had to work within VS Code's extension API, which limits how deeply you can integrate with the editing experience.
Cursor forked VS Code. They took the entire editor and modified it at the source level. This means they control the rendering pipeline, the file system interactions, the tab management, everything. AI isn't bolted onto the editor — it's woven into every interaction.
The difference shows up in small but important ways. When Cursor suggests a multi-file edit, it can show inline diffs across multiple tabs simultaneously. It can modify the file tree. It can run terminal commands and parse the output. An extension can't do most of this.
// In a VS Code extension, you're limited to the Extension API:
vscode.workspace.applyEdit(workspaceEdit); // basic text edits
vscode.window.showInformationMessage(msg); // simple notifications
// Cursor modifies the editor core directly:
// - Custom diff rendering across split panes
// - Inline code generation with real-time syntax highlighting
// - Terminal integration that feeds output back to the AI
// - File tree modifications as part of AI suggestions
The tradeoff is real — Cursor users can't use every VS Code extension seamlessly, and updates lag behind VS Code mainline. But for the AI-first workflow, the depth of integration is worth it.
Composer 2 Changed the Game
Cursor's Composer feature, launched in its second major iteration earlier this year, is what turned the editor from "Copilot but nicer" into something genuinely different. Composer lets you describe a change in natural language and the AI implements it across your entire codebase.
But here's the key: it doesn't just generate code and dump it in your files. It shows you a plan, lets you approve or modify individual steps, and applies changes incrementally. You stay in control but the AI does the tedious work.
I tested it on a real task last week — adding pagination to a REST API that had nine endpoints, each needing cursor-based pagination with consistent error handling. In the old world, that's an hour of repetitive work. With Composer 2, I described the pattern once, reviewed the first endpoint's implementation, approved it, and Composer applied the same pattern to the remaining eight endpoints with appropriate modifications for each.
# I described: "Add cursor-based pagination to all list endpoints.
# Use the same pattern as the users endpoint but adapt for each resource."
# Composer 2 generated changes across 9 files:
# routes/users.py - already had pagination (used as reference)
# routes/orders.py - added cursor param, modified query, added next_cursor
# routes/products.py - same pattern, adapted for product-specific sorting
# routes/reviews.py - same pattern, handled nested relationships
# ... 5 more files
# Each file got contextually appropriate modifications,
# not just find-and-replace templating.
# The orders endpoint correctly paginated by created_at DESC,
# while products used a composite cursor of (category, id).
That's not autocomplete. That's codebase-aware transformation. And it works well enough that developers trust it with real production code.
The Pricing Is Aggressive
Cursor Pro costs $20/month. For that you get unlimited AI completions, 500 "fast" requests per month to frontier models (GPT-4, Claude), and unlimited "slow" requests. The free tier gives you 2,000 completions per month — enough for a casual user to get hooked.
Compare that to GitHub Copilot at $10/month for just completions, or Copilot with the chat features at $10/month but with less capable editing integration. Cursor costs more but delivers more.
The 50,000 business customers are on Cursor Business at $40/user/month, which adds team features, admin controls, and privacy guarantees. At enterprise scale, $40/user/month for a tool that measurably increases developer productivity is easy to justify. Engineering time is expensive.
What Keeps Users Stuck
I talked to a dozen developers who switched to Cursor in the last six months. The pattern is consistent: they tried it for a week, and now they can't go back.
The reason isn't any single feature. It's the compound effect of small improvements. Tab completion that understands your current change intent. A chat panel that has full context of your project structure. Multi-file diffs that render cleanly. Terminal output that automatically feeds back into the AI's understanding.
Each of these is maybe 5% better than the alternative. But they stack. And because they're integrated at the editor level rather than the extension level, they feel seamless rather than bolted on.
The network effect is kicking in too. When your team uses Cursor, you share .cursorrules files that configure the AI's behavior for your project. These accumulate project-specific knowledge — coding conventions, architecture patterns, testing approaches — that make the AI better for everyone on the team.
Where Cursor Struggles
It's not all roses. The VS Code fork means Cursor is perpetually playing catch-up with VS Code updates. Some extensions don't work correctly. Remote development support is improving but still behind VS Code's native implementation.
Performance can be an issue on large projects. The indexing that enables Cursor's codebase awareness takes time and memory. On a monorepo with millions of lines of code, the initial index can take 15-20 minutes and consume several gigabytes of RAM.
And the elephant in the room: vendor lock-in. If Cursor gets acquired, changes pricing dramatically, or shuts down, you've built your workflow around a tool you can't easily replace. Your .cursorrules files, your muscle memory, your team's processes — all tied to one startup.
The Bigger Picture
Cursor's success tells us something about where developer tools are heading. The IDE isn't just a text editor anymore — it's an AI orchestration layer. The value isn't in syntax highlighting or git integration. It's in how deeply the AI understands your codebase and how seamlessly it can modify it.
A million daily users in a market this competitive means Cursor found something real. Whether they keep the lead as Microsoft, Google, and JetBrains pour resources into their own AI integrations is the billion-dollar question. But right now, they're executing better than companies with a hundred times their resources.
That should make every developer tool company nervous.
Top comments (0)