Cursor: the AI-powered editor and its agent mode

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 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.

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 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 tokens and your components.

Cursor offers several layers:

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.

How much does it cost?

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

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
• Cursor: agent documentation
• Cursor: rules documentation
• Cursor: Tab documentation
• Cursor: migrating from VS Code
• Cursor: VS Code migration help (Open VSX and shortcuts)