What Is Cursor?

// In plain English

Cursor is a code editor — the thing you type your programs into — with a powerful AI built directly into its core. If you've used VS Code, Cursor will feel immediately familiar: same layout, same keyboard shortcuts, most of the same extensions. The difference is that the AI isn't bolted on as a plugin; it's woven into every part of the editor, from the suggestions it makes as you type to a full-blown agent that can rewrite files across your entire project.

A useful mental model: think of Cursor as VS Code with a very senior developer permanently sitting next to you. That developer knows your whole codebase — not just the file you have open — and can do three things on demand: 1. Finish your sentences (Tab autocomplete that predicts multi-line edits, not just the next word). 2. Answer questions about your code in a chat panel, with the relevant files already loaded. 3. Take over a task — you describe the goal, Cursor's Composer writes the changes across however many files are needed, and you review a single diff before anything is saved.

// Why it matters

Earlier AI coding tools were extensions that knew only the file you had open. If you asked "how should I update the cart component?" the AI had no idea what a cart was in your project — it couldn't see your data models, your API layer, or your existing tests. You had to paste all that context in manually every time.

Cursor indexes your entire project on disk. When you ask a question or start a task, it automatically pulls in the relevant files from across your codebase, so answers are grounded in your actual code rather than generic patterns. This is the leap from "a smarter autocomplete" to "an assistant that actually knows this project."

Who should use Cursor

• Beginners who want to learn by doing: ask Cursor to explain any piece of code, fix an error, or add a feature, and watch exactly what changes and why.
• Developers with VS Code muscle memory who want serious AI features without switching toolchains.
• Anyone doing cross-file refactoring — renaming a data model, splitting a module, migrating an API — where changes need to stay consistent across dozens of files at once.
• Teams who want a shared baseline: Cursor's cursor rules file (similar to a .editorconfig) lets you encode project conventions the AI follows for every team member.

// How it works

Cursor has four interlocking systems that work together. Understanding each one helps you get the most out of it.

Tab autocomplete

As you type, Cursor shows a grey ghost suggestion for the next few characters, lines, or even whole blocks. Press Tab to accept. Unlike traditional autocomplete (which looks up function names from a list), Cursor's suggestions are generated by a model that has seen your file and recently opened files — so it can suggest the right variable name, the correct argument order for your API, or an entire loop that matches the pattern you've been writing.

Codebase indexing and @ context

When you open a project, Cursor scans and indexes every file in the background. This index powers semantic search — finding code by meaning, not just text matches. You can then reference anything in a chat message using @ mentions:

• @filename — pin a specific file into the conversation so the AI reads it in full.
• @codebase — tell the AI to search the whole indexed project for relevant code before answering.
• @Docs — attach documentation for a framework (React, Django, etc.) so suggestions follow its conventions.
• @Web — let the AI fetch a live URL for you (useful for changelogs or API docs you don't have locally).
• @errors — automatically attach your current compiler or linter errors as context.

The key insight is that more context is not always better. Cursor's internal research found that stuffing every file into the prompt dilutes the AI's attention and produces generic answers. The @ system lets you be deliberate: start with @codebase to discover which files matter, then switch to specific @filename mentions for focused edits.

Composer — multi-file editing

Composer is Cursor's most powerful feature. You open it with Cmd/Ctrl+I, describe a task in natural language — "Add a password-reset flow: a forgot-password page, a reset-token API endpoint, and email the user a link" — and Cursor generates a coordinated set of changes across however many files are involved. You see a single unified diff. Review, tweak, and click Apply to write everything to disk at once.

Composer has two modes. Normal mode proposes a diff and waits for your approval before touching any file — good for focused tasks where you want to review everything. Agent mode lets Cursor run commands (like installing a package or running tests), read the output, and iterate on its own until the task succeeds — good for open-ended tasks where you'd rather review the final result.

Model selection

Cursor is model-agnostic — it routes your requests to the frontier model of your choice. As of 2026, the supported models include Anthropic's Claude family, OpenAI's GPT-4 series, Google's Gemini 2.5 Pro, and DeepSeek. You switch models from a dropdown in the chat or Composer panel.

A built-in Auto mode picks the best model for the task automatically and is unlimited on paid plans. Manually selecting a premium model (like Claude Opus 4 or GPT-4.1) draws from your monthly credit pool instead. This lets you use fast/cheap models for quick questions and powerful models for complex refactors.

// Pricing and plans

Cursor moved to a credit-based pricing model in mid-2025. Every paid plan includes a monthly credit pool (equal to the plan price in dollars) that depletes based on which AI models you use. Auto mode is unlimited — credits only count when you manually pick a premium model.

A Teams plan ($40/user/month) adds admin controls, SSO, and usage dashboards for organizations. Enterprise pricing is available for larger deployments with custom security requirements.

// Going deeper

Cursor Rules — your project's AI config

A .cursor/rules file (or cursorrules in older versions) is a plain-text file you commit to your repo. It tells the AI your conventions: preferred language, naming rules, which libraries to use, which to avoid, how you want tests structured. Every chat message and Composer task automatically inherits these rules — so the AI writes code that looks like your codebase, not generic tutorial code.

Background and Cloud Agents

Cursor v3.0 (early 2026) introduced Background Agents — tasks you can kick off and let run while you work on something else. The agent opens a sandboxed copy of your repo, completes the task, and surfaces a pull request for your review. You're not blocked waiting for it to finish. Cloud Agents go further: they run on Cursor's infrastructure rather than your local machine, useful for long-running tasks that would slow your laptop.

MCP tool support

Cursor supports the Model Context Protocol (MCP), the open standard for giving AI agents access to external tools. You can connect Cursor to databases, issue trackers, documentation systems, or internal APIs — anything with an MCP server — so the AI can read live data as part of its context. See What Is MCP? for background.

Practical workflow tips

• Start with @codebase to explore, then narrow to @specific-file for edits — broad discovery first, precise editing second.
• Use Composer in Normal mode for tasks touching critical files; switch to Agent mode when you want it to run tests and iterate autonomously.
• Write a .cursor/rules file early — even five lines about your stack and naming conventions dramatically improve suggestion quality.
• Keep your work in git — Cursor's Agent mode can and will overwrite files. A clean commit before a big Composer run means any mistake is a one-line git checkout to undo.
• Switch models intentionally — use Auto for quick questions, manually select Claude Opus 4 or GPT-4.1 only when the task genuinely needs maximum reasoning.