Cursor

Cursor is a fork of VS Code rebuilt around an AI pair-programmer. The headline difference from a chat window bolted onto an editor is the index: Cursor embeds your repository so that chat, inline edits, and the agent all answer with your actual code in view rather than a generic guess. Because it is a VS Code fork, your extensions, themes, keybindings, and settings.json come across on first launch — the switching cost is close to zero, which is a large part of why it spread the way it did.

How it actually works

Three surfaces, and it pays to know which one you're in:

• Tab (autocomplete) — a custom model tuned for multi-line, multi-cursor edits. It predicts the next edit, not just the next token, so it will often offer to update the three other call sites after you rename a parameter.
• Inline edit (Cmd/Ctrl+K) — select code, describe the change, review a diff in place. This is the right tool for a bounded, local change.
• Agent / Composer (Cmd/Ctrl+I) — a full agent loop: it reads files, runs terminal commands, edits across the tree, and iterates until the task is done. This is the right tool for "add a migration and wire it through", and the wrong tool for "rename this variable".

Context is a skill, not a setting

Cursor's answers are only as good as the context you hand it. The @ menu is the main lever:

A rule of thumb that survives contact with real repos: name the two or three files that matter instead of hoping the index finds them. Semantic search is good; it is not clairvoyant, and a wrong-file answer costs more to unpick than the ten seconds an @file would have taken.

Rules: the part teams underuse

Project rules live in .cursor/rules/*.mdc and are the durable version of every correction you'd otherwise retype each session — "use our Result<T> type, not exceptions", "tests go in tests/, mirroring the source tree", "no new dependencies without asking". Rules can be always-on, auto-attached by glob (**/*.tsx), or invoked by name. Cursor also reads AGENTS.md, which means the same instruction file can serve several agents.

Checking rules into git is the point: it turns one person's hard-won prompt discipline into the team's default.

Standout capabilities

• Multi-file edits from a single instruction, presented as a reviewable diff
• Codebase-wide semantic search that understands symbols, not just strings
• Frontier model choice per request, plus a Max mode for larger context windows
• MCP servers, hooks, and cloud/background agents on paid tiers
• Agentic code review and shared team context on the Teams plans

Pricing shape

A free Hobby tier with limited agent requests; Individual plans starting around $20/month with Pro+/Ultra steps that multiply the agent allowance; Teams at roughly double that per seat, adding centralized billing, SSO, privacy mode, and usage analytics; and custom Enterprise pricing with pooled usage, SCIM, and audit logs. Every plan bundles an amount of model usage with on-demand spend beyond it — check cursor.com/pricing before budgeting, because the tiers are re-cut fairly often.

Best for

Developers who live in an editor all day and want the AI in the same window as the code. It is strongest on a repository with recognizable structure and weakest on a sprawling monorepo where "the codebase" is too big to be a useful noun.

Where it struggles

• Very large monorepos — indexing takes a while and retrieval gets noisier; scope the agent to a package rather than the root.
• Silent over-reach — the agent will happily refactor adjacent code you didn't ask about. Commit before you start so git diff is your undo.
• Confidence on unfamiliar frameworks — it will invent a plausible API. Pair it with @docs or a test.

Getting started

1. Install, then sign in and let the initial index finish before you judge it.
2. Open a repo you know well and ask it something you already know the answer to. That's how you calibrate its trustworthiness cheaply.
3. Write one rule file, even a five-line one. It changes the hit rate more than any model switch will.
4. Use inline edit for local changes and reserve the agent for tasks you would otherwise have scheduled an hour for.

Worth knowing

Privacy mode (and enforced privacy mode on Teams) controls whether code is retained. If you work under a customer NDA, settle that setting before the first prompt, not after.