What Is Cursor? The AI-Native Editor Explained

// In plain English

Cursor is a code editor — the program you type your code into every day — rebuilt from scratch around AI. If you have used VS Code, Cursor will feel instantly familiar: the same sidebar, the same command palette, the same keyboard shortcuts, and most of the same extensions. The fundamental difference is that the AI is not an add-on you can remove. It is woven into the text buffer itself, which changes what it can do for you.

Here is the everyday analogy. Imagine VS Code is a car with GPS bolted onto the dashboard as an afterthought — useful, but always a separate device. Cursor is a car where navigation is built into the dashboard, steering wheel, and speedometer from the factory. Both cars get you where you are going, but the built-in version knows your speed, your fuel level, and your route at the same time, so it can give smarter, faster guidance.

Concretely, Cursor gives you three modes of AI help that work together: a Tab key that predicts your next multi-line edit instead of your next word; a chat panel that already has your whole codebase indexed and loaded as context; and an agent mode that can plan and execute a multi-file task while you watch — or while you make a coffee.

// Why it matters

The standard critique of AI coding plugins is that they are file-blind. They know the few hundred lines currently on your screen. Ask one "how should I wire this new API endpoint into the existing auth layer?" and it will either hallucinate an answer or tell you to paste the relevant code in yourself. For a large project with hundreds of files, that pasting step becomes the bottleneck.

Cursor solves this with automatic codebase indexing. The moment you open a project, it walks every file, breaks the code into logical chunks (functions, classes, modules), encodes each chunk as a vector embedding that captures its meaning, and stores the result in a local index. Queries issued through chat or agent mode run a two-stage retrieval: first a vector search to find candidate chunks, then a reranker to prioritise by relevance. The AI answers questions about your actual codebase, not about a generic version of it.

The problem with the plugin model

Extensions like GitHub Copilot talk to the editor through a published API designed for text manipulation, not for deep AI integration. That API boundary limits what the extension can see and do. Cursor's AI sits below that API boundary — at the level of the text model and the language server — so it can intercept cursor movements, watch test output, read terminal errors, and react to all of it in real time. That architectural difference is what makes agent mode possible: the AI can notice a test failure in the terminal and immediately propose a fix, without you doing anything.

// How it works

Cursor exposes three overlapping AI surfaces. Each is designed for a different granularity of task, and together they cover the full range from finishing a single expression to building a new feature end-to-end.

Tab completion

Cursor's Tab key is powered by a model derived from Supermaven, a company Cursor acquired in late 2024. The model holds a 100,000-token context window so it can see far more of your file — and related files — than a standard single-file autocomplete. It predicts multi-line completions: entire function bodies, matching error-handling branches, test cases mirroring the style of your existing tests. Press Tab to accept, or keep typing to decline. The predictions appear in grey ghost text before you finish your thought.

Inline edit (Cmd/Ctrl+K)

Highlight a block of code, press Cmd+K (Mac) or Ctrl+K (Windows/Linux), and type a natural-language instruction: "make this function async and add retry logic". Cursor applies the change in place and shows a diff overlay so you can accept or reject every hunk before it touches your file. This is the fastest path for targeted, surgical edits — faster than opening the full chat panel because the model knows the scope is limited to your selection.

Chat panel

The chat panel (Cmd+L) opens a conversation window that already has your codebase index loaded. You can ask architectural questions ("which files handle authentication?"), request explanations of unfamiliar code, or ask it to draft a new component. The panel can attach specific files with @filename mentions, pull in documentation with @docs, or reference web pages with @web. Responses can include code snippets you apply directly into the editor with a single click.

Agent mode

Agent mode (Cmd+I) is where Cursor becomes something qualitatively different from an autocomplete. You give it a high-level goal — "add a dark-mode toggle to the settings page and wire it to the theme store" — and Cursor's agent plans the work, opens and edits the relevant files, runs the dev server or test suite via the integrated terminal, reads any error output, and iterates until the task is done. You review a unified diff at the end.

// Cursor vs VS Code + Copilot: the real differences

People often ask whether they should just install GitHub Copilot into VS Code instead of switching editors. The honest answer is: it depends on your workflow. Here is a side-by-side comparison of the key dimensions.

The headline gap is codebase awareness. A Copilot suggestion is grounded in whatever fits in the open file's context window. A Cursor suggestion is grounded in the vector-indexed representation of your entire project. For solo developers working on small scripts, this difference is barely noticeable. For anyone maintaining a codebase with dozens of interconnected modules, it is the difference between an assistant that understands the project and one that is guessing.

The second gap is model flexibility. Cursor lets you pick which underlying AI model handles each request. You can route routine Tab completions through a fast, cheap model and reserve expensive frontier models (like Claude Sonnet or GPT-4o) for complex agent tasks. This routing control is not available when you are locked to a single provider's extension.

// Plans and pricing

Cursor offers a free Hobby tier, which gives you roughly 2,000 code completions and 50 slow premium-model requests per month — enough to evaluate the product seriously before paying anything. Paid plans run on a credit-based system introduced in mid-2025, where each dollar of credit maps to a certain number of model requests depending on which model you use.

The credit model means your effective cost varies by model choice. A session that runs entirely on Gemini Flash will spend credits much more slowly than one that calls Claude Sonnet for every request. You can monitor credit usage in Cursor's settings panel and set model preferences per-surface (Tab, chat, agent) to keep costs predictable.

// Rules, context, and customisation

One of Cursor's most underrated features is its Rules system. Rules are persistent instructions that get prepended to every AI request in the project, so you never have to re-explain your conventions. The legacy format was a single .cursorrules file at the project root; the current format (as of 2025) uses individual .mdc files inside a .cursor/rules/ directory, which lets you scope rules to specific file patterns or tasks.

Common uses for rules include: specifying your preferred language version ("always use Python 3.12 type hints"), naming conventions ("use camelCase for JS variables, snake_case for Python"), testing frameworks ("write tests with pytest, not unittest"), or project-specific invariants ("never commit secrets to environment files"). The AI follows these rules silently without you having to remind it each session.

Context anchors: @-mentions

In the chat and agent panels you can anchor context explicitly using @-prefixed mentions. @filename pulls in a specific file. @docs fetches a documentation URL and adds it to the conversation. @web performs a live web search. @codebase triggers the full semantic index search. These anchors let you guide the AI's attention without manually pasting large amounts of code.

// Going deeper

Once you are comfortable with the three main surfaces, several advanced capabilities unlock significantly more power.

Subagents and background agents

Cursor v3.0 (early 2026) introduced Background Agents and Cloud Agents, which run on Cursor's infrastructure rather than your local machine. You can dispatch a long-running task — "migrate all API calls to the new SDK version" — and close your laptop; the agent runs in the cloud and pushes a branch when it finishes. Subagents, added in v2.4 (January 2026), let a primary agent spawn independent child agents for parallel subtasks, each with their own context window, so a large refactor can be broken into concurrent workstreams.

How codebase indexing works under the hood

Cursor uses tree-sitter to parse source code into abstract syntax trees, then slices the tree at function and class boundaries to create semantically coherent chunks. Each chunk is passed through a dedicated encoder model that heavily weights comments and docstrings — the human-readable descriptions of what code does — before generating the vector embedding. The index updates every 5 minutes by reprocessing only changed files. File paths are encrypted before leaving your machine; code content is never stored in plaintext on Cursor's servers.

Choosing the right model for the right task

Cursor lets you assign different models to different surfaces. A sensible default for most Pro users is: fast models (Gemini Flash, Claude Haiku) for Tab completions where latency matters most; mid-tier models (Claude Sonnet, GPT-4o mini) for chat where you want thoughtful answers without blowing the credit budget; and frontier models (Claude Sonnet 4, GPT-4o) reserved for agent sessions where accuracy over a long multi-file task justifies the cost.

Is Cursor the right tool for you?

Cursor pays its biggest dividends on medium-to-large codebases where codebase awareness matters and where multi-file agent tasks are a meaningful part of the workday. If you mostly write self-contained scripts or notebooks, the free Hobby tier is likely sufficient — or a lightweight plugin may be all you need. If you maintain a service with dozens of modules, write features that touch multiple layers of the stack, or want to delegate entire sub-tasks to an autonomous agent, Cursor's architecture is a genuine step up from the plugin model. The student tier and 14-day Pro trial make the comparison easy to run without financial commitment.