How to Use Cursor AI: Setup, Agents & Pricing (2026)

TL;DR: Cursor is an AI code editor built on VS Code, and as of October 2026 (version 3.23) it’s as much an agent manager as an editor. You describe a change, Agent edits the files and shows you a diff, and Plan Mode or Cloud Agents take on the bigger jobs. Pro costs $20/month. This guide covers setup, the features worth learning, project rules, shortcuts, current pricing, and an honest comparison with GitHub Copilot.

How to Use Cursor AI (Quick Start)

To use Cursor AI, download the editor from cursor.com, sign in, and open a project folder. Press Cmd+I (Ctrl+I on Windows and Linux) to open Agent, then describe the change you want in plain English. Cursor searches your codebase, edits the files, and shows a diff you review before keeping anything.

The whole loop in six steps:

1. Download Cursor from cursor.com and sign in.
2. Import your VS Code setup (extensions, themes, keybindings) from Cursor Settings.
3. Open a project folder and press Cmd+I to open Agent.
4. Ask Agent to explain the codebase before you change anything.
5. Press Shift+Tab for Plan Mode when a change touches several files.
6. Review the diff, then ask Agent to run your tests or build.

Steps 4 and 6 come straight from Cursor’s own quickstart.

What Is Cursor AI?

Cursor AI is an AI-native code editor that turns natural language into working code across your entire project. Unlike extensions that add AI to an existing editor, Cursor was built around AI assistance from the start. It’s built on the VS Code codebase, so your extensions, themes, and keybindings carry over, but the AI integration goes much deeper than a plugin can.

The biggest change this year came with Cursor 3, released April 2, 2026. It added the Agents Window, an agent-first workspace where you run several agents in parallel across local folders, cloud machines, and remote SSH hosts. The classic editor is still there when you want to read and write code yourself. Cursor also ships its own models now: Composer 2.5, and Grok 4.7, which it trained with SpaceXAI.

Cursor AI is an AI-powered code editor built on VS Code that generates, edits, and refactors code from natural language prompts. It reads your full project, not just the open file, and can make coordinated changes across many files in a single conversation. Plans start at free, with Pro at $20 per month.

If you’re still choosing between editors, my roundup of the best AI coding tools puts Cursor next to the alternatives.

Cursor’s homepage now describes it as “your coding agent for building ambitious software.”

How to Set Up Cursor AI (Step by Step)

Getting Cursor running takes a few minutes. Here’s exactly what to do.

Step 1: Download and Install

Go to cursor.com and download the installer for macOS, Windows, or Linux. On Linux, Cursor recommends its apt or dnf packages over the AppImage, since they include automatic updates and the CLI tools.

Step 2: Import Your VS Code Settings

Open Cursor Settings with Cmd+Shift+J (Ctrl+Shift+J on Windows/Linux), go to General > Account, and click Import under VS Code Import. That brings over your extensions, themes, settings, and keybindings in one step, so the editor feels familiar right away.

Step 3: Sign In and Choose a Plan

Sign in or create an account. Google, GitHub, Apple, and email sign-in are all offered. The free Hobby plan needs no credit card and is enough to find out whether Cursor fits how you work. If you code every day, Pro ($20/month) is the plan I’d start with.

Step 4: Pick Your Model

Choose a model from the picker under the Agent input, or press Cmd+/ (Ctrl+/) to cycle through them. As of October 2026, Cursor’s model list includes:

• Cursor’s own models: Composer 2.5 and Grok 4.7 (plus the older Grok 4.6 and 4.5)
• Anthropic: Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1, and Claude Haiku 5.5
• OpenAI: GPT-5.6 Sol, Terra, and Luna
• Google: Gemini 3.1 Pro and Gemini 3.8 Flash
• Meta: Muse Spark 1.3

Auto lets Cursor pick the model for each request, but it’s no longer a free, unlimited lane: every Auto request bills at the list price of the model it routes to. Cursor’s own models draw from a separate pool with more included usage, and Composer 2.5 is cheap to run ($0.50 per million input tokens, versus $4 for Claude Opus 5.5), so it’s a sensible default for everyday edits.

Step 5: Set Up Project Rules

This is the step most developers skip, and it makes the biggest difference. Rules are persistent instructions Cursor adds to the model’s context, so Agent follows your conventions without being told every time.

Create a .cursor/rules/ directory in your project root and add .mdc files. The extension matters: Cursor ignores plain .md files in that folder, because they have no frontmatter telling it when to apply the rule.

.cursor/
  rules/
    code-style.mdc      # alwaysApply: true
    components.mdc      # globs: src/components/**/*.tsx
    api-patterns.mdc    # description: when Agent should pull it in
AGENTS.md               # optional plain-markdown alternative

Each rule’s frontmatter decides when it loads. This one attaches whenever a component file is in context:

---
globs: src/components/**/*.tsx
alwaysApply: false
---

- Use named exports, not default exports
- Keep components under 200 lines

A rule can apply to every chat, when Agent judges it relevant from its description, when a matching file is in context, or only when you @-mention it. Type /create-rule in Agent and Cursor writes the file for you. To skip frontmatter entirely, use an AGENTS.md file in the project root or any subfolder.

Step 6: Start Coding with AI

You’re set up. Open a project and try these three things:

1. Start typing. Tab suggestions appear as gray text; press Tab to accept one.
2. Select code and press Cmd+K (Ctrl+K), then describe the change for an inline edit.
3. Press Cmd+I (Ctrl+I) to open Agent for multi-file tasks, and Shift+Tab to switch it into Plan Mode.

Essential Cursor AI Features

Cursor packs in a lot. These are the features that matter most in daily use.

Tab Completion

Tab is Cursor’s autocomplete. It suggests code as you type based on your recent edits, the surrounding code, and linter errors. It can change several lines at once, add missing imports, and suggest matching edits in other files.

Tab is the feature you’ll use most. Press Tab to accept a suggestion, or keep typing to ignore it. Press Tab again after accepting and Cursor jumps to the next spot it predicts you’ll edit. Pro and higher plans include unlimited Tab completions.

Cmd+K: Inline Editing

Select a block of code, press Cmd+K, and describe what you want to change in plain English. Cursor rewrites the selection in place.

Use cases:

• “Add error handling to this function”
• “Convert this to async/await”
• “Make this component responsive”

It’s the fastest way to make a targeted change without leaving your editing flow. In the terminal, Cmd+K turns a plain-English request into a command.

Agent (Cmd+I)

Agent is Cursor’s most capable feature and the core of what makes vibe coding possible. Press Cmd+I to open it in the side panel, and you get an assistant that can:

• Search your codebase and the web
• Read and edit multiple files
• Run terminal commands and watch the output
• Control a built-in browser to test pages and take screenshots
• Ask clarifying questions while it keeps working

Describe a feature in plain English and Agent builds it across your project. It shows a diff for every file it touches, and Cursor saves checkpoints before significant changes, so you can roll the files back if Agent takes a wrong turn. Want a first project to try it on? My step-by-step vibe coding walkthrough builds a working app from a single idea.

Plan Mode

Press Shift+Tab in the Agent input to switch to Plan Mode. Instead of writing code right away, Agent researches your codebase, asks clarifying questions, and produces a plan you can edit before you click build. Use it for anything that spans several files. If a build goes sideways, Cursor’s advice is to revert, tighten the plan, and rerun it rather than patching with follow-up prompts.

The Agents Window

Cursor 3 added the Agents Window, an agent-first interface you open from the command palette (Cmd+Shift+P, then Open Agents Window). It’s built for running many agents at once, each in its own Git worktree, with a diffs view for reviewing and committing changes. Its built-in browser hosts Design Mode (Cmd+Shift+D): click an element in your running app, or draw on the page, and tell the agent what to change. Open IDE takes you back to the classic editor.

Cursor’s Agents page shows the agent-first layout: running and finished agents on the left, a plan ready to build on the right.

@ Mentions

Type @ in the Agent input to attach specific context instead of pasting code into chat:

• @filename or @folder/ to include files or folders
• @Terminals for terminal output
• @Chats for context from a previous conversation
• @Commit or @Branch for your uncommitted changes or full branch diff
• @Browser for context from the built-in browser

Older tutorials mention @codebase, @web, and @docs, which aren’t in Cursor’s current list. Agent now searches your codebase and the web on its own.

Cloud Agents

Cloud Agents run the same agent on isolated virtual machines instead of your laptop. (Older guides, including the first version of this one, called them Background Agents.) Start one from the desktop app by picking Cloud under the agent input, from cursor.com/agents, the iOS app, Slack, or by commenting @cursor on a GitHub PR or issue. Each one works on its own branch and pushes changes back for review, with screenshots, videos, and logs of how it checked its work.

Use Cloud Agents for:

• Refactors that touch many files
• Writing test suites
• Migrating code patterns across a project
• Fixing bugs while you work on features

Cloud Agents run on isolated VMs with their own development environment, so they can build, test, and use the software they change. They need a paid plan and a connected GitHub, GitLab, Bitbucket, or Azure DevOps account, and they bill at the API price of the model you pick.

Automations and Bugbot

Automations run cloud agents on a schedule or in response to events from GitHub, GitLab, Slack, Linear, webhooks, and more. Example: a GitHub issue gets the “bug” label, and an automation starts a cloud agent that writes a fix on a new branch and opens a PR for you to review. Typing /automate in a local agent session lets you describe a workflow in plain language and have Cursor set it up.

Cursor also runs managed review agents. Bugbot checks pull requests for bugs (included on Teams, usage-billed on individual plans), and Security Agents scan PRs and codebases for vulnerabilities.

MCP Servers

MCP (Model Context Protocol) servers connect Cursor’s agent to external tools like databases, issue trackers, and design generators. Install official ones with one click from the Cursor Marketplace, or add your own in .cursor/mcp.json (one project) or ~/.cursor/mcp.json (every project). My guide to the best MCP servers for AI coding tools covers which ones are worth installing.

For UI work, the MCP server I connect in Cursor is AIDesigner. Design Mode is good for adjusting an interface that already runs; AIDesigner handles the step before that, generating the design itself.

Run npx -y @aidesigner/agent-skills init cursor, connect aidesigner under Customize > MCPs, and finish the browser sign-in. Agent can then call generate_design for a responsive HTML design, refine_design to iterate, and generate_website_design_image for visual references, then port the result into your components.

The free tier includes 5 lifetime credits, no card required. My Claude Code frontend design guide walks through the same design-to-code loop.

Cursor and Claude Code both support reusable skills (see my Claude Code skills guide), and my Claude Code vs Cursor comparison covers which tool wins for which workflow.

Cursor Keyboard Shortcuts Cheat Sheet

Accept and reject apply when Agent has suggested changes. Every shortcut can be remapped, and Cursor’s keyboard shortcuts reference lists the rest. Keep this table open for the first week; the shortcuts become muscle memory quickly.

Cursor vs GitHub Copilot: Which Should You Use?

This is the question every developer asks. Here’s my honest answer after using both.

GitHub Copilot works inside the editors you already use, on GitHub, and in the terminal.

Cursor is better for multi-file editing, agent-heavy workflows, and developers who want an AI-native editor. GitHub Copilot is better for staying in the IDE you already use, tight GitHub integration, and a lower starting price. Neither tool is universally better. The right choice depends on your workflow.

Side-by-Side Comparison

Sources: Cursor pricing and GitHub Copilot plans, both checked October 2026.

When to Choose Cursor

Choose Cursor if you regularly refactor across many files, want AI that understands your full project, or want an editor where every feature is designed around agents. The extra $10 a month over Copilot Pro is worth it the first time Plan Mode and Agent ship a feature that touches a dozen files in one conversation. If Agent becomes your main way of working, plan for Pro+ rather than Pro (more on that in the pricing section).

When to Choose GitHub Copilot

Choose Copilot if you work in Visual Studio, Eclipse, Xcode, or a JetBrains IDE and want completions plus agent mode where you already are (Cursor’s JetBrains integration brings its agent, not the whole editor). It also fits teams that live on GitHub, where you can assign an issue to Copilot’s cloud agent and get a pull request back. At $10/month, Copilot Pro covers what many developers need for half the price of Cursor Pro.

For full-stack app generation rather than code editing, see my guide to Bolt.new alternatives, which covers tools like Lovable and Replit.

Can You Use Both?

Yes. One split that works: Cursor for hands-on editing, and Copilot’s cloud agent for issues you assign on GitHub. Copilot’s cloud agent works from GitHub, so it doesn’t matter which editor you use to review the pull request it opens.

7 Tips for Getting the Most Out of Cursor

1. Write Rules for Every Project

This is the single highest-impact thing you can do. Rules (.mdc files in .cursor/rules/, or an AGENTS.md) tell Agent your coding standards, preferred patterns, and architecture decisions. Without them, Cursor writes generic code; with them, it writes code that fits your project. Cursor’s own advice is to start small and add a rule when you see Agent repeat the same mistake.

2. Plan Before You Build

For anything bigger than a quick fix, press Shift+Tab and let Plan Mode research the codebase and ask its questions first. Editing a plan is much cheaper than unwinding a half-built feature.

3. Mention Files Only When You Know They Matter

Use @filename when you know which files are relevant. When you don’t, skip it and let Agent search, which is what Cursor’s docs recommend. Stuffing the context with guesses mostly adds noise.

4. Pick a Run Mode Deliberately

Run Modes, set in Settings > Agents > Approvals & Execution, control what Agent can do without asking. Auto-review runs known-safe calls, sandboxes shell commands where it can, and sends the rest to a classifier; Cursor calls it the safest useful setup for most people. Allowlist only auto-runs actions you’ve approved. Run Everything, the closest thing to the old “YOLO mode,” skips every prompt.

Pair a less restrictive mode with tests: write them first, then let Agent iterate until they pass.

5. Send Long Tasks to Cloud Agents

Don’t sit and wait on a big refactor. Hand it to a Cloud Agent, keep working on your main feature, and review the branch when it’s done. In the Agents Window, /in-cloud hands a task from a local session to a cloud subagent.

6. Start Small, Then Go Bigger

Begin each Agent conversation with a focused request. Once it delivers the first piece, expand the scope. That beats dumping a massive specification upfront. If a step goes wrong, restore a checkpoint instead of arguing with the agent.

7. Review Every Diff Before Accepting

AI-generated code needs review. Cursor shows a diff for every change. Read them. The tool saves you hours of typing, but the few minutes you spend reviewing prevent bugs that would cost hours to debug.

How Much Does Cursor AI Cost? (2026 Pricing)

Cursor costs nothing on the Hobby plan, $20 per month for Pro, $60 for Pro+, and $200 for Ultra. Teams costs $40 per user per month for a Standard seat or $120 for Premium, and Enterprise pricing is custom. Every paid plan includes monthly model usage, with on-demand usage at API rates after that.

Developers in India also get Start, a ₹649/month plan that covers only Cursor’s own models.

Cursor’s pricing page in October 2026: Hobby (free), Individual ($20/mo Pro, with Pro+ and Ultra tiers), Teams ($40/user/mo), and Enterprise (custom).

How Cursor Usage Works

Cursor no longer counts requests; its docs label request-based plans as legacy. Pro, Pro+, and Ultra split usage into two pools that reset each billing cycle:

• Cursor Models: Grok 4.7, Grok 4.6, Grok 4.5, and Composer 2.5, with significantly more included usage
• Other Models: Claude, GPT, Gemini, and other third-party models, charged at each model’s API price

The key detail: Auto requests bill at the list price of the model they route to, so a heavy Auto month draws down your included usage like any manual pick.

For most developers, Pro at $20/month is the right starting plan. The free tier works for evaluation but runs out quickly during active development. If Agent is your main workflow, budget honestly: Cursor’s pricing docs say daily Agent users typically spend $60 to $100 a month in total usage, and power users running multiple agents often pass $200. That’s why Cursor recommends Pro+ for daily Agent users and Ultra for power users.

Who Should Use Cursor AI?

Cursor is the right tool if you:

• Write code daily and want AI built into every part of your editor
• Do multi-file refactoring or cross-project changes regularly
• Want to describe features in plain English and have agents build them, locally or in the cloud
• Are comfortable reviewing AI-generated diffs before accepting

Cursor is probably not the right tool if you:

• Want to stay in Visual Studio, Eclipse, Xcode, or a JetBrains IDE full-time (Copilot covers those directly)
• Mostly need inline completions without agentic features
• Want the cheapest paid option (Copilot Pro is $10/month)

If you’re building web applications, landing pages, or UI prototypes, you might also want to look at AI design tools that generate interfaces from text prompts, or no-code app builders if you want to skip coding entirely. Both complement Cursor’s code-focused workflow.

Frequently Asked Questions

Is Cursor AI free?

Yes, Cursor has a free Hobby plan that needs no credit card. It includes limited Agent requests and access to Cursor’s Composer model, which is enough to evaluate the editor. For daily use, paid plans start at $20 per month for Pro, which adds extended Agent limits, frontier models, unlimited Tab completions, and Cloud Agents.

What is the difference between Cursor and GitHub Copilot?

Cursor is a standalone AI code editor built on VS Code, with Plan Mode, parallel agents, and Cloud Agents built in. GitHub Copilot works inside editors you already use, including VS Code, Visual Studio, JetBrains IDEs, Eclipse, and Xcode, plus GitHub itself. In my experience, Cursor is stronger for large refactors and agent-heavy work. Copilot Pro costs $10 per month, half the price of Cursor Pro.

Is Cursor AI worth $20 a month?

For developers who refactor across many files or rely on Agent daily, yes, in my experience. Budget realistically, though: Cursor’s docs say daily Agent users typically spend $60 to $100 a month in total usage, which is why Cursor recommends Pro+ for them. If you mostly need inline completions, Copilot’s free plan or its $10 Pro plan may be enough.

Can beginners use Cursor AI?

Yes. Cursor is built on VS Code, so the interface is familiar to most developers. Beginners can describe what they want in plain English, and Plan Mode asks clarifying questions before writing any code. Cursor’s own quickstart suggests asking Agent to explain an unfamiliar codebase first, which is a good habit for anyone learning.

What AI models does Cursor use?

As of October 2026, Cursor offers its own Composer 2.5 and Grok 4.7 models alongside Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1, GPT-5.6, Gemini 3.1 Pro, and others. Auto picks a model for each request and bills at that model’s list price. Cursor’s own models draw from a separate usage pool with significantly more included usage.

Does Cursor replace VS Code?

For most developers, yes. Cursor is built on the VS Code codebase and supports the same extensions, themes, keybindings, and settings. You can import all of them from Cursor Settings > General > Account > VS Code Import. Two differences to know: Cursor often runs a slightly older VS Code version for stability, and its activity bar is horizontal by default.