Cursor

What it is and how it works

Cursor is a fork of Visual Studio Code, built by Anysphere, that bakes AI assistance directly into the editor core rather than bolting it on as an extension. This architectural choice matters: because Cursor owns the fork, it can do things a VS Code extension cannot easily do — rewrite the diffing and multi-file edit UI, control keystroke-level latency for inline suggestions, and maintain a persistent index of the open codebase for retrieval. The most visible product of this is Cursor Tab, its inline completion engine, which predicts not just the next few tokens but often the next edit — including changes elsewhere in the file — and lets you accept it with a single keypress. It is model-agnostic in principle and has, over its life, used a mix of in-house-tuned models and frontier models from OpenAI, Anthropic, and others depending on the feature and the user's plan.

Beyond inline completion, Cursor ships an agentic chat panel that can read the codebase, propose multi-file diffs, run terminal commands (with confirmation), and iterate against build/test output. It also offers "background agents," which run longer, semi-autonomous coding tasks — checking out a branch, making changes, and reporting back — without requiring the developer to babysit every step. This puts Cursor in a different lane from a pure autocomplete tool: it is trying to be both the fast, low-friction "flow state" completion tool and a delegate-a-task agent, in the same product.

Because Cursor is closed source and runs its core AI features against cloud inference, there is no local/offline mode for the actual model calls — the gpuSupported field of "n/a (uses cloud)" reflects that your local GPU is irrelevant to how Cursor generates suggestions; all the heavy lifting happens on Anysphere's or its model providers' infrastructure. Your machine just runs the VS Code-derived editor and sends context (open files, selections, sometimes broader codebase snippets) up to the cloud for each request. This is an important distinction for a site focused on local AI: Cursor is not a "run the model on your own hardware" tool, it's a cloud-AI product wrapped in a familiar local IDE shell.

Deployment patterns

For a solo developer, Cursor installs like any VS Code fork — download, sign in, and it imports your existing VS Code settings, keybindings, and (with some compatibility caveats) extensions. Most solo users run it exactly like VS Code day to day, with Cursor Tab active for completions and the chat/agent panel opened on demand for larger refactors or unfamiliar codebases. The friction point solo users hit first is the pricing tier: the free tier is limited, the ~$20/mo Pro tier is the realistic entry point for daily use, and heavy agentic users often graph into the higher tiers (up to the ~$200/mo Ultra tier) because agent and premium-model usage consumes request quota quickly.

In a team setting, Cursor is typically deployed per-seat via its business/team plans, which add centralized billing, admin controls, and (on higher tiers) privacy-mode guarantees that prevent code from being retained for model training. Some engineering orgs standardize on Cursor as the default IDE and manage API-key/model-provider policy centrally so individual developers aren't each configuring their own keys. Because it is a fork of VS Code, teams with existing VS Code extension packs, dotfiles, or devcontainer setups usually migrate with minimal friction, though enterprises with strict code-exfiltration policies need to evaluate the cloud data path carefully — this is not a self-hostable, air-gapped tool. There is no server/homelab deployment pattern for Cursor itself, since the inference backend is entirely Anysphere's cloud, not something you stand up yourself.

How it compares

Cursor's closest competitor is GitHub Copilot (including Copilot Chat and Copilot Workspace), which is also a cloud-backed, subscription-priced assistant but ships as a conventional VS Code/JetBrains extension rather than a fork. Copilot is generally considered less aggressive in its inline-edit predictions than Cursor Tab and has historically lagged in agentic, multi-file editing capability, but it has the advantage of being extension-based (works inside your existing editor setup with fewer migration decisions) and is bundled more cheaply for many GitHub/Enterprise customers. Windsurf (formerly Codeium's IDE) is architecturally closest to Cursor — also a VS Code fork with an agentic "Cascade" flow — and the two are frequently compared head-to-head on completion quality and agent reliability; the honest answer is that the gap between them shifts release to release, so any specific competitive edge should be treated as temporary rather than durable. For developers who want AI assistance without leaving a non-VS-Code editor entirely, JetBrains AI Assistant or Zed's built-in AI features serve similar niches within their own ecosystems, and Zed in particular appeals to those who want a much lighter, faster-native editor than an Electron-based VS Code fork.

Best use cases and honest limitations

Cursor is a strong fit for developers who already live in VS Code and want the least-friction path to fast inline completion plus an agent that can execute real multi-file changes — the editor familiarity genuinely reduces the switching cost that pure-agent CLI tools impose. It's also a reasonable choice for teams standardizing on one AI-assisted IDE, since the Cursor Tab experience is widely regarded as one of the tightest inline-completion loops available as of 2026.

The honest limitations: it is closed source, so there's no auditing the model-selection logic, prompt construction, or telemetry beyond what Anysphere documents, and no self-hosting path exists — this disqualifies it outright for anyone requiring air-gapped or fully local inference. Pricing tiers are a recurring complaint; the jump from casual to heavy agentic usage can push a user from the base plan into Ultra territory faster than expected, since premium-model and background-agent calls draw down request budgets quickly. Cursor has also had publicized privacy and extension-marketplace controversies (including scrutiny over telemetry and over how it has handled compatibility with the official VS Code/Open VSX extension ecosystems), which is worth factoring in for anyone with strict data-handling requirements. If your workflow is genuinely local-only — no code ever leaves the machine — Cursor is the wrong tool regardless of how good its completions are; it should be evaluated as a cloud-AI-assisted IDE, not a local AI tool that happens to run on your desktop.

Download the installer from cursor.com — available for macOS, Windows, and Linux. Cursor is a VS Code fork with deep AI integration built in, not bolted on as extensions. After install, sign in with your Cursor account (free tier available, Pro starts at $20/month). Open any project folder. The AI features are: (1) Tab — inline completions that predict your next edit (not just next token), triggered as you type; (2) Cmd+K — inline code generation/editing: highlight code, describe the change, Cursor applies it; (3) Cmd+L — chat sidebar with full project context, can reference files and run terminal commands; (4) Agent mode — Cursor acts autonomously, reading files, running commands, and iterating. All features use Cursor's own model routing (default models include Claude 4 and GPT-5). Compatible with VS Code extensions and settings — Cursor reads your existing VS Code config. Verify: open any file, press Cmd+K, type "add error handling", see the diff applied. Time-to-first-action: ~3 seconds for Tab completions, ~10 seconds for chat/agent responses. No API keys needed — Cursor handles backend model access.

Best for: developers who want a single AI-native IDE with best-in-class inline editing and agentic features without managing extensions, full-stack web development where Cmd+K refactoring across multiple files accelerates common patterns, prototyping and greenfield work where Agent mode can scaffold entire features, developers moving from VS Code who want AI features deeper than extensions can provide. Not suited for: developers deeply invested in JetBrains or Neovim workflows (Cursor is VS Code-based), offline/air-gapped environments (Cursor requires cloud connectivity), teams with strict budget constraints ($20/month for Pro), developers who need provider flexibility (Cursor abstracts model selection), enterprise environments requiring self-hosted AI with data locality control.

Use Cursor when you want the best all-in-one AI coding IDE with native model integration, inline editing, and agentic features without managing extensions, API keys, or backend providers — it's the most polished AI-native IDE available. Switch to Claude Code when you want a dedicated terminal agent with maximum autonomy and prefer CLI-native workflows. Use Aider for git-centric pair programming with provider flexibility — Cursor locks you into Cursor's model selection. Use Cline inside VS Code when you want an agentic extension without switching IDEs — Cursor is a full IDE fork. Use GitHub Copilot when you want completions that work across every IDE (VS Code, JetBrains, Neovim) — Cursor is its own IDE. Cursor's Tab model (next-edit prediction vs next-token completion) is the best inline AI experience, and the Cmd+K inline editor is the fastest way to make targeted code changes. Its tradeoff: vendor lock-in to Cursor's editor, model selection, and pricing.

Problem: Tab completions are slow (>2 seconds) or don't appear. Fix: Cursor's Tab model requires low latency. Ensure you're on a fast internet connection (Tab pings Cursor's servers, not Anthropic/OpenAI directly). In Settings → Models, ensure "Cursor Tab" is enabled. If on a VPN, add Cursor to split tunneling. Problem: Agent mode modifies files you didn't intend. Fix: Agent mode in Cursor operates on the current workspace with access to all files. Use .cursorrules file in your project root to constrain agent behavior: "Do not modify files outside src/ without asking." Enable "Ask before file writes" in Settings → Features → Agent. Problem: Existing VS Code extensions break after switching to Cursor. Fix: Cursor is a fork and most extensions work, but some that use VS Code-proprietary APIs may fail. Settings sync (~/.vscode) is imported on first launch. If an extension fails, check the Cursor logs (Help → Toggle Developer Tools) for the specific error. Reinstall the extension from the Cursor marketplace.