Cursor appeared in 2023 with a concrete pitch: take VS Code, fork it, and make AI a first-class citizen of the editor rather than a side plugin. The bet is aggressive — a startup competing against Microsoft + OpenAI on their turf — but the result deserves attention. This article is an honest read after months of daily use: what it does well, where it loses to Copilot, and when it makes sense to adopt.
What Cursor Is Exactly
Cursor is a VS Code fork with native modifications for AI assistance:
- Inline completion (like Copilot, but with stronger models available).
- Chat with code embedded in the editor — side panel aware of open-file and project context.
- Edit mode (formerly “Ctrl+K”): select code, describe the change, AI applies it.
- Composer (since v0.4x): multi-file editing from a brief, designed for complete features.
- Swappable models: GPT-4, Claude 3 Sonnet (then Opus), whichever you prefer.
As a VS Code fork, you keep most extensions: Prettier, ESLint, Docker, Remote SSH, Dev Containers. It’s not a “new” editor with its own ecosystem — it’s the same editor with a more deeply integrated AI layer.
Daily Flow Changes
After a week of use, the mental shift is real. Three patterns become natural:
- “Explain this”: select an old function and request explanation. Faster than reading unknown code.
- “Refactor to X”: describe the refactor (extract function, change API, add tests) and it applies. Review diff.
- “Generate from comment”: write an extensive comment and request implementation. Useful for clear boilerplate.
The diff is always yours to approve. No hidden changes. Quality depends hugely on chosen model (Claude 3 Sonnet very good; GPT-3.5 clearly worse).
Composer: Where It Stands Out
Composer mode is Cursor’s differentiator. You give a multi-file brief (“add JWT authentication to these endpoints, create middleware, update tests”) and it proposes changes across multiple files at once, with reviewable diffs.
Where it works well:
- Small but multi-file features: add an endpoint, a new page, a shared type.
- Consistent refactors: renaming a concept across many places.
- Guided migrations: “switch from moment.js to date-fns across the project”.
Where it fails:
- Large architectural changes. Loses context, invents inconsistent patterns.
- Highly domain-specific code. Doesn’t understand implicit business rules.
- Enormous monorepo projects. Context doesn’t fit.
Discipline matters: well-scoped tasks and critical review of the resulting diff.
Cursor vs Copilot
The two dominant commercial options. Honest comparison:
Cursor:
- Superior multi-file Composer.
- More powerful models available (Claude 3 Opus, GPT-4 Turbo).
- Richer project-context chat.
- Well-integrated “edit” mode.
Copilot:
- More stable and polished (it’s older).
- Better enterprise integration (seat management, policies, SAML).
- Very fast inline completion.
- Price and ubiquity advantage.
Practical decision: Cursor if you value advanced workflows and frontier models. Copilot if you value simplicity, stability, and corporate contracts.
Models and Pricing
The Cursor Pro plan includes GPT-4 and Claude 3 Sonnet access. Claude 3 Opus and longer requests are counted separately (fast-credit system). Options:
- $20/month Pro (GPT-4 included).
- Business plan for teams.
- Local mode (BYO API key) lets you use your OpenAI/Anthropic account with direct costs.
The BYO API key option is critical for enterprises with centralised AI billing.
Privacy Considerations
Cursor sends context (open files, selections, project) to models. For NDA projects or regulated code:
- “Privacy mode”: Cursor promises not to retain your data.
- Local model via proxy: Cursor 0.42+ supports pointing to Ollama/your own API for self-hosted models. Limited vs frontier.
- Legal and security review before deploying on teams with sensitive code.
Permissively-licensed open code: less critical. Critical proprietary code: careful evaluation.
Tooling Integration
As a VS Code fork:
- GitLens, Remote SSH, Dev Containers, Prettier, ESLint: work.
- Linters and formatters: unchanged.
- Debugger: same.
- Jupyter Notebooks: supported.
- Some Microsoft-specific extensions (Pylance, Remote-WSL in certain scenarios) may have friction.
For most teams, migration is a one-day task.
What’s Missing
- Team features: centralised management, shared prompts, audit. Improving but still behind Copilot Enterprise.
- Non-VS-Code IDE support. No version for IntelliJ, RustRover, etc.
- Edge cases in very large files. May suggest changes outside visible context.
- Your own AI backend integration. If your company has a corporate LLM proxy, connecting it needs manual configuration.
When to Recommend It
Adopt Cursor if:
- Your team already uses VS Code.
- You value modern features (Composer, better models).
- You can justify per-developer cost.
- Code privacy isn’t a blocker.
Stick with Copilot (or alternatives) if:
- Your company has a Copilot Enterprise contract.
- Your IDE fleet is heterogeneous (IntelliJ, etc).
- You prefer stability and less change.
- Strict privacy — Copilot has more mature enterprise terms.
Conclusion
Cursor is the first editor that feels designed to work with AI, not “AI bolted on”. The multi-file Composer experience and chat integration make real daily-life differences. It has weaknesses — team management, VS-Code IDE lock-in, privacy — but its trajectory is solid. For individual developers and small teams, it’s today’s best bet. For large enterprises with Copilot contracts and mixed IDE fleets, value is less clear. The decade will be defined by how editors restructure around AI; Cursor is today’s reference for that restructuring.
Follow us on jacar.es for more on developer tools, productivity, and AI-assisted editing.
