# Cursor: the AI-powered editor and its agent mode

> Cursor is a VS Code-based editor with an agent that edits files, runs commands and follows project rules. What it offers, how to set it up and what it costs.

*Tags: ai, tools, editor, agents*

---


> [!info] Quick Definition
> **Cursor** is a code editor built on VS Code with an AI agent built in. The agent can read the project, edit several files, run terminal commands and follow the rules you define. It lets you work with code conversationally without leaving the editor.


## What does Cursor's agent offer?

The agent opens in the side panel with Cmd+I (on Mac). The official documentation describes it as able to "complete complex coding tasks independently, run terminal commands, and edit code." Among the tools the documentation lists:

- **Search, read and edit files**, including images such as PNG or SVG.
- **Run commands** in the terminal and monitor their output.
- **Browser**: take screenshots, test the app and verify visual changes.
- **Fetch rules** by type and description, and **ask questions** to clarify something.

It also has **checkpoints**: snapshots of the codebase saved during an agent session. You can preview one and restore your files to that state. Two details matter: restoring only reverts files, it does not remove messages from the conversation, and checkpoints are stored on your machine, separate from git. They are for undoing agent changes, not a project history.

For long jobs, the documentation mentions the `/goal` command, which sets a long-running objective (for example, "fix all flaky tests and make CI green"); the same page says it is rolling out gradually, so you may not see it yet. The `/loop` command repeats a prompt or skill on an interval. And in Projects, "a coordinator agent plans the work and delegates it to other agents," somewhat like the [[background-agents|background agents]] of other tools.

## What is Tab and how is it different from the agent?

Tab is Cursor's AI autocomplete. As you type, it proposes code as grayed-out text ahead of your cursor, based on your recent edits, the surrounding code and linter errors. It is not limited to one line: it can change several lines, add missing imports and suggest coordinated edits across related code.

You accept it with the Tab key, reject it with Escape or by typing on, and you can accept it word by word with Cmd + Right Arrow (Ctrl + Right Arrow on Windows and Linux).

The practical difference: Tab helps while **you** type; the agent works on its own from an instruction. To tweak a CSS value, Tab is enough; to change a component across five files, use the agent. There is more context in [[ai-autocomplete|AI autocomplete]].

## Why does it matter to a designer?

Because the editor is where design turns into code. With Cursor open on your project's repo, you can ask for a visual change, review the diff in the same place and try it in the browser. Even so, it helps to understand [[git-for-designers|git]] to review what changed.

If you come from VS Code, the switch is short. Cursor can import extensions, themes, settings and keybindings from VS Code with one button in its settings, and it shares the same default shortcuts. One warning: it uses the Open VSX extension registry, not the VS Code Marketplace, so an extension may be missing or behave differently.

## How do you set up project rules?

Rules are the thing you should learn most. An agent without rules invents colors and components; one with rules uses your [[design-tokens-for-agents|tokens]] and your [[components-and-agents|components]].

Cursor offers several layers:

| Type | Where it lives | What it is for |
|---|---|---|
| Project rules | `.mdc` files in `.cursor/rules`, inside the repo | Code conventions; versioned with git |
| AGENTS.md | Markdown file at the root (and in subfolders) | Simple instructions, no metadata |
| User rules | Customize → Rules | Your own preferences across all projects |
| Team rules | Cursor dashboard (Teams and Enterprise plans) | Shared rules an admin can make required |

Watch the extension: a plain `.md` file inside `.cursor/rules` is ignored; it has to be `.mdc`. Each `.mdc` rule defines in its header when it applies: always (`alwaysApply: true`), when the agent finds it relevant from its description, when files matching a pattern (`globs`) are in context, or only when you mention it with `@rule-name`. When rules conflict, team rules win, then project rules, then user rules.

The documentation recommends keeping each rule under 500 lines, referencing files instead of copying their contents, and starting small: add a rule only when you see the agent repeat the same mistake. If you already use AGENTS.md with other tools, see [[claude-md-and-agents-md|CLAUDE.md and AGENTS.md]].

## How much does it cost?

According to Cursor's pricing page, checked on October 18, 2026, which shows monthly prices in USD:

| Plan | Monthly (USD) | What it includes, roughly |
|---|---|---|
| Free | 0 | Limited agent and chat usage |
| Plus | 8 | Shared usage pool; Grok models only |
| Premium | 30 | 4 times Plus usage; cloud agents, automations, AI code reviews, third-party models at API list price |
| Super | 100 | 15 times Plus usage; priority model access at peak times |
| Ultra | 200 | 50 times Plus usage; earliest access to products and models |
| Teams | From 30 per user | Centralized billing, usage analytics, SSO, shared rules |
| Enterprise | Custom | Invoice or purchase-order billing, SCIM, audit logs, spend controls |

The page also says the included usage refreshes weekly, that third-party model usage inside Cursor is billed separately by usage, that prices exclude taxes and that they can change. Note the Plus plan: if you need models other than Grok, it will not work for you.

## When should you NOT use Cursor?

- When you only need to edit one small file. A simple editor is enough.
- When your agent usage is heavy and the plan does not cover it. Check the weekly limit and the cost of third-party models before depending on it.
- When you rely on an extension that only exists in the VS Code Marketplace.
- When you have no version control. Checkpoints are local and only cover agent changes; git is still your safety net.

## Example

Illustrative example: a designer has a website repo open in Cursor. First she creates `.cursor/rules/styles.mdc` with `globs: src/**/*.css` and three lines: use only variables from `tokens.css`, never write hex colors, and respect the spacing scale.

Then she opens the agent with Cmd+I and asks: "Change the heading of the pricing page to use `Heading` from `src/components`, with the size from the type scale." The agent finds the component, edits two files and starts the server. She reviews the diff, compares in the browser and sees the spacing came out larger than she wanted. She restores the previous checkpoint and repeats the request with the exact token name. This time the result matches, and she saves it with a commit.

The rule prevented invented colors, the checkpoint gave her room to experiment and the commit kept the change safe. Accepting it was her decision.

## Common mistakes

- Accepting changes without looking at the full diff.
- Saving rules as `.md` inside `.cursor/rules`: Cursor ignores them.
- Not defining rules and repeating the same instructions in every chat.
- Treating a checkpoint as a commit. Checkpoints are local and do not replace git.
- Asking for many changes at once instead of small tasks.
- Choosing a plan without checking which models and how much usage it includes, especially for a large team.

## Sources

- [Cursor: pricing page](https://cursor.com/pricing)
- [Cursor: agent documentation](https://cursor.com/docs/agent/overview)
- [Cursor: rules documentation](https://cursor.com/docs/context/rules)
- [Cursor: Tab documentation](https://cursor.com/docs/tab/overview)
- [Cursor: migrating from VS Code](https://cursor.com/docs/configuration/migrations/vscode)
- [Cursor: VS Code migration help (Open VSX and shortcuts)](https://cursor.com/help/getting-started/migrate-vscode)


---

Source: https://www.fernandoux.com/en/wiki/ai/cursor/