Cursor AI Code Editor

Cursor is an AI-first code editor, built as a fork of VS Code and developed by Anysphere. It embeds frontier models from Anthropic, OpenAI, Google and SpaceXAI, plus its own Composer model, directly into the editing experience so that autocomplete, multi-file edits, and codebase-wide queries happen inside a single tool rather than across a browser tab and an IDE. For developers building AI applications, Cursor removes the context-switching that slows down every cycle of the coding loop.

Official site: https://cursor.com
Documentation: https://docs.cursor.com
Changelog: https://cursor.com/changelog

Current models (September 2026)

Cursor’s documentation, checked on 25 September 2026, lists these as its current models: Claude Opus 5.5, Claude Sonnet 5, Claude Fable 5.1, Gemini 3.1 Pro, Gemini 3.8 Flash, Muse Spark 1.3, GPT-5.6 Sol, Terra and Luna, Grok 4.7, 4.6 and 4.5, and Composer 2.5. Three details matter when you pick one:

• Claude Opus 5.5 is listed at $4 input / $20 output per 1M tokens with $0.20 cache reads, 20% below Claude Opus 5, with a 300K default and 1M maximum context. Claude Opus 5 is still listed but hidden by default. See Claude Opus 5.5 .
• Grok 4.7 is described by Cursor as “jointly trained by Cursor and SpaceXAI”. It sits in Cursor’s own “Cursor Models” usage pool with Grok 4.6, Grok 4.5 and Composer 2.5, which carries significantly more included usage than the third-party pool. Its standard window in Cursor is 256K, extendable to 500K at 2x rates. Grok 4.7 Fast, the same model at 2x price, is available only in Cursor and SpaceXAI’s Grok Build, not on the public xAI API, and Cursor makes Fast the default speed tier on Pro and higher plans. See Grok 4.7 .
• GPT-6 is not listed yet. OpenAI released GPT-6 Astra (3 September) and GPT-6 Sol and Luna (22 September), and GitHub Copilot added all three, but Cursor’s model list and pricing page still stopped at GPT-5.6 on 25 September 2026. Check the Cursor changelog before assuming GPT-6 access.

How Cursor fits into the stack

Installation and first-time setup

Download the installer from cursor.com . Cursor ships native packages for macOS, Windows, and Linux.

# macOS: open the downloaded .dmg and drag Cursor to Applications
# Linux: download the .AppImage or .deb, then:
chmod +x cursor-*.AppImage && ./cursor-*.AppImage
# or
sudo dpkg -i cursor-*.deb

On first launch, Cursor imports your VS Code settings, extensions, and keybindings automatically. Sign in with a GitHub or Google account to activate your plan.

Connect to a project:

# Open any existing project from the terminal
cursor /path/to/your/project

# Or open the current directory
cursor .

Cursor indexes your codebase in the background after you open a project. The index enables @codebase queries and powers the relevance ranking for Composer. For large monorepos, indexing takes a few minutes on first open and stays current as files change.

Install your existing VS Code extensions:

Open the Extensions panel (Cmd+Shift+X on macOS). All extensions from the VS Code Marketplace install and run identically inside Cursor.

Core features

Tab completion

Cursor’s tab completion goes beyond single-line suggestions. It reads the surrounding context, including adjacent functions and imported modules, and fills multiple lines at once. Press Tab to accept the full suggestion or use the arrow keys to step through alternatives.

# You type the function signature and docstring
def calculate_discount(price: float, user_tier: str) -> float:
    """Return discounted price based on user tier."""

# Cursor completes the body:
    tiers = {"gold": 0.20, "silver": 0.10, "bronze": 0.05}
    discount = tiers.get(user_tier, 0)
    return price * (1 - discount)

The model reads the user_tier parameter name, the docstring, and the return type annotation to generate a pattern-consistent implementation rather than a generic placeholder.

Composer and Agent mode

Composer (Cmd+I on macOS) is the multi-file editing interface. You describe what you want in plain English. Cursor reads the relevant files, generates a diff across all affected files, and presents the changes for review. You accept, reject, or modify before anything is written to disk.

Example: add input validation to a FastAPI endpoint

Open Composer and type:

Add Pydantic input validation to the POST /users endpoint in routes/users.py.
The request body must include email (valid email format) and name (non-empty string).
Return a 422 with a clear error message if validation fails.

Cursor reads routes/users.py, identifies the existing endpoint signature, generates the Pydantic model, imports it, and updates the route handler. The diff shows every line changed. Review and press Accept All to apply.

Example: refactor to async/await

Refactor get_user_by_id() in services/user_service.py to use async/await.
Update all callers in routes/users.py and tests/test_users.py to match.

Cursor traces the call graph, updates the three files, and presents the full diff. This task would take 10-15 minutes manually; Composer produces it in under 30 seconds.

Agent mode extends Composer with terminal access. Cursor can run commands (install packages, run tests, check linting) as part of the task and loop until the output confirms success.

Chat: Cmd+L

Chat (Cmd+L) opens a conversation panel pinned to the right of the editor. Use it to ask questions about the codebase without making changes.

What does the @file:services/auth_service.py token_refresh() function do,
and why does it call revoke_old_tokens() before issuing the new token?

Cursor reads the file, traces the function, and explains the logic. The answer includes references to the specific lines. Click a reference to jump directly to that location in the editor.

Chat also accepts code selections. Highlight a block, press Cmd+L, and ask about the selected code only.

@-symbols: pinning context

The @ prefix pins specific sources into the model’s context window:

Example: use @file to give targeted context

Using @file:schemas/invoice.py as the source of truth for the Invoice model,
write a serialization function that converts an Invoice to the format expected
by the QuickBooks API documented at @web:https://developer.intuit.com/app/developer/qbo/docs/api/accounting/all-entities/invoice

Cursor fetches the URL, reads the schema file, and generates the serialization function against both sources simultaneously.

Rules: persistent behavior instructions

Create a .cursor/rules/ directory at your project root and add .mdc files to encode project-specific conventions. Cursor loads these rules on every Composer and Chat session.

mkdir -p .cursor/rules

# .cursor/rules/python.mdc
- Use `async/await` for all I/O-bound operations. Never use synchronous `requests` in FastAPI routes.
- All functions must have type annotations on parameters and return values.
- Error handling uses `HTTPException` with explicit `status_code` and `detail`. No bare `raise`.
- Tests use `pytest` with `pytest-asyncio`. Test files mirror the source path: `routes/users.py` -> `tests/routes/test_users.py`.

Rules eliminate the need to repeat conventions in every prompt. They are committed to the repo so the whole team shares the same Cursor behavior.

Background agents

Background agents run tasks outside the editor without blocking your current session. Start a background agent from the Cursor dashboard or via the command palette:

Run the full test suite, identify any failures caused by the auth refactor,
and propose fixes without applying them yet.

The agent runs pytest, reads the failure output, traces the source of each failure, and returns a summary with proposed diffs. You review the results and apply selectively.

Background agents are useful for long-running tasks (test suites, database migrations, build verification) that would otherwise block the interactive session.

Composer workflow

Cursor vs alternatives

Windsurf, which had itself absorbed the Codeium brand, is now part of Cognition: as of 26 September 2026, windsurf.com redirects to Cognition’s Devin Desktop, and its pricing page lists Devin plans.

Key differentiator: Cursor’s combination of Claude’s long context window, semantic codebase indexing, and multi-file Composer puts it ahead of plugin-based tools for complex refactors and greenfield feature development. Devin Desktop (formerly Windsurf) is the closest alternative and is worth evaluating if you prefer a different pricing model. GitHub Copilot remains the default choice for teams already inside the GitHub Enterprise ecosystem where SSO and audit logging are pre-configured.

Pricing

Prices from cursor.com/pricing , checked 25 September 2026, exclusive of tax. Every plan includes a set amount of model usage, drawn from two monthly usage pools: “Cursor Models” (Grok 4.7/4.6/4.5 and Composer 2.5) and “Other Models” (third-party models at the provider’s API price plus a Cursor Token Rate). Once the included amount is used, on-demand usage is billed in arrears. See Cursor’s models and pricing page for per-model rates.

The Hobby tier is enough to evaluate Cursor for a single project. Pro is the practical minimum for professional use. Teams is required for teams that need SSO, centralised billing or an organisation-wide privacy mode.

Heavy Agent and Composer sessions on premium third-party models draw down the “Other Models” pool quickly; check the usage dashboard before assuming a flat fee covers a month of intensive work.

When not to use Cursor

Your team requires a specific enterprise IDE. JetBrains IDEs (IntelliJ, PyCharm, WebStorm) and Eclipse have deep integrations with enterprise toolchains: profilers, debuggers, build systems, and code review plugins tuned to those environments. Cursor has no equivalent. If your team’s workflow depends on IntelliJ’s refactoring engine or a proprietary JetBrains plugin, switching editors carries a real cost.

Your project requires an air-gapped or offline environment. Cursor sends code to external model APIs. There is no fully offline mode. For classified projects, regulated environments with strict data residency, or networks without outbound internet access, Cursor is not suitable. Look at GitHub Copilot with a self-hosted Azure OpenAI endpoint, or JetBrains AI with a local model.

Context window costs are a concern at scale. Each Composer session sends tens of thousands of tokens to the model API. Each plan includes a fixed usage allowance, with on-demand usage billed beyond it. If you run Cursor on behalf of a team under the Teams plan, or integrate it into automated pipelines, model usage can scale beyond the included allocation. Monitor usage per seat before rolling out to large teams.

You need deterministic, reproducible builds in CI. Cursor is an interactive editor, not a pipeline tool. For automated code generation in CI/CD, use the Anthropic API or OpenAI API directly with version-pinned models.

Further reading

• Cursor documentation : official reference for all features, keybindings, and configuration options
• Cursor rules community repository : community-maintained collection of .cursor/rules/ files for common frameworks and languages
• What is vibe coding? : foundational explainer for the AI-assisted development workflow that Cursor is built around
• Claude Anthropic : the Claude models (Opus 5.5, Sonnet 5, Fable 5.1) available in Cursor
• OpenAI API : the current GPT-5.6 lineup available as Cursor’s OpenAI model option
• Anthropic model documentation : current Claude model IDs, context windows, and pricing
• Context engineering vs prompt engineering : why what you include in the context window matters more than how you phrase the instruction
• Cursor changelog : weekly release notes; Cursor ships updates at a pace that makes the changelog more useful than any third-party summary

Sources

1. Cursor, Models & Pricing (usage pools, per-model rates, Claude Opus 5.5, Grok 4.7 and Grok 4.7 Fast rows), checked 25 September 2026: https://cursor.com/docs/models-and-pricing
2. Cursor, Grok 4.7 model page (256K/500K context, effort levels, Fast default on Pro and higher): https://cursor.com/docs/models/grok-4-7
3. Cursor, Models documentation (current model list and context windows): https://cursor.com/docs/models
4. xAI, Grok 4.7 overview (“Grok 4.7 Fast … available only in Cursor and Grok Build”): https://docs.x.ai/developers/grok-4-7
5. This wiki, “Grok 4.7”: /news/grok-4-7/
6. This wiki, “Claude Opus 5.5”: /news/claude-opus-5-5/
7. Cursor, Pricing (Hobby, Pro $20, Pro+ $60, Ultra $200, Teams $40/user, Enterprise), checked 25 September 2026: https://cursor.com/pricing
8. GitHub Docs, “Plans for GitHub Copilot” (Free, Pro $10, Pro+ $39, Max $100, Business $19, Enterprise $39), checked 25 September 2026: https://docs.github.com/en/copilot/get-started/plans
9. Devin Desktop (windsurf.com redirects here) and Devin plans and pricing, checked 26 September 2026: https://devin.ai/desktop , https://windsurf.com/pricing