What Is Cursor AI and How to Use It (2026): The AI-Native VS Code Fork, Tab to Agent

What is Cursor AI? An AI-native code editor (a VS Code fork by Anysphere)

Cursor AI is an AI-native code editor — a VS Code fork built by Anysphere — where AI is a primitive of the editor rather than a bolted-on extension. You download it from cursor.com and drive it through four AI surfaces: Tab (autocomplete), Cmd+K (inline edit), Cmd+L (chat), and Cmd+I (the Agent for multi-file work). Because it’s a fork, your existing VS Code extensions, themes, and keybindings carry over, so it feels familiar on day one.

I run Cursor in production every day; this is the getting-started guide I wish I’d had. The mental model is simple: everything else is a familiar VS Code editor, so most of this post is about when to reach for each of the four AI surfaces. Cursor reported 500,000+ developers as of early 2026, and the reason isn’t magic — these four surfaces cover the full range from “finish this line” to “refactor across twelve files.”

Install Cursor from cursor.com — your extensions, themes, and keybindings carry over

Go to cursor.com and download the build for macOS, Windows, or Linux — it’s a normal desktop app, no CLI install ritual. On first launch, Cursor offers to import your VS Code setup, and because it’s a fork, that import is real: your extensions, themes, and keybindings come across intact. Vim mode, your color scheme, forty extensions — all of it survives the move.

Open a folder the way you would in VS Code:

cursor .

That cursor shell command is installed from the command palette (Cmd+Shift+P → “Install ‘cursor’ command”). Once a project is open, Cursor indexes it in the background — hold that thought, because that index is what makes @codebase work later. First, the surface you’ll touch most: Tab.

Tab: predictive multi-line autocomplete and smart rewrites

Tab is Cursor’s predictive autocomplete, and it goes well beyond finishing a single word. It predicts multi-line edits — whole blocks, the next few statements, the closing of a pattern you started — and it does “smart rewrites,” meaning it will fix a typo or a minor error as part of the suggestion rather than blindly completing what you typed. You accept a suggestion with the Tab key.

The workflow: keep typing normally, and ghost text appears ahead of your cursor. If it’s right, press Tab; if it’s close, keep typing and it re-predicts. What sets Tab apart from ordinary autocomplete is that it reads the surrounding file, so when you rename a variable on line 10 it’ll often propose the matching edit on line 40 and jump you there. You don’t prompt Tab — you write code and let it keep pace. For anything you can’t express by typing, reach for the prompt bar.

Cmd+K / Ctrl+K: the inline edit prompt bar

Press Cmd+K (macOS) or Ctrl+K (Windows/Linux) and a small prompt bar opens right at your cursor. This is inline edit: you describe a change in plain language and Cursor generates or rewrites code in place. Select a block first and Cmd+K scopes the edit to that selection; use it on an empty line and it generates new code where you are.

This is the surface for surgical, local changes — the ones too fiddly to type but too small to hand to the Agent:

Cmd+K → "convert this callback to async/await and add error handling"

Cursor shows a diff inline; you accept or reject. Because it edits in place, Cmd+K is the right tool when you know exactly which lines should change and just want them written for you. When the change is a conversation rather than a single instruction, switch to chat.

Cmd+L / Ctrl+L: the AI chat panel

Cmd+L (macOS) or Ctrl+L (Windows/Linux) toggles the AI chat panel — a conversational, iterative surface that sits beside your editor. This is where you ask questions (“why is this request timing out?”), reason through a design, or paste an error and work toward a fix over several turns. Chat keeps the thread, so you can refine (“okay, now do it without adding a dependency”) instead of re-explaining from scratch.

Chat is read-and-discuss by default — the surface for understanding code and planning changes. The distinction from Cmd+K is intent: Cmd+K commits an edit to your file immediately, while Cmd+L is a discussion you apply from when you’re ready. If you’re new to agentic coding, my primer on what an AI agent is frames why “chat that can also act” is a different tool than a chatbot. And when the work outgrows a single file, there’s a fourth surface for exactly that.

Cmd+I / Ctrl+I: the Agent (Composer) for multi-file, project-wide work

Cmd+I (macOS) or Ctrl+I (Windows/Linux) opens the Agent — historically called Composer — a unified, project-wide surface that can edit across multiple files and run tasks. This is the heavy machinery. You give it a goal (“add pagination to the users endpoint and update the client hook and the tests”), and it plans, touches every file involved, and presents the changes together for review.

The Agent is what people mean when they say Cursor “writes features.” It reasons across your project, proposes a multi-file diff, and can run commands as part of the task. Review its diff the way you’d review a colleague’s pull request — the Agent is fast and capable, but it’s still your name on the commit. The Agent is only as good as the context you give it — which is where @ symbols come in.

Give it context with @ symbols: @file, @folder, @codebase

Rather than let the AI guess what “the auth module” means, you point at context explicitly with @ symbols. Type @ in any AI surface and Cursor offers completions:

@file        → attach one specific file
@folder      → attach an entire directory
@codebase    → let the AI semantically search the whole project

So instead of pasting code into chat, you write “refactor @file src/auth/login.ts to use @file src/lib/session.ts” and Cursor pulls in the real, current contents. @folder means “consider everything in this directory,” and @codebase is the big one — it turns your whole project into searchable context. Precise @ references are the single biggest quality lever you have; vague prompts get vague diffs. But @codebase only works because Cursor has already built an index — so it’s worth understanding what that index is.

Codebase indexing: how vector embeddings power @codebase

When you open a project, Cursor builds an index of your files using vector embeddings. That’s what powers @codebase semantic search: instead of grepping for a string, the AI searches a real map of your code’s meaning, so “where do we validate the RFC?” finds the right function even if it’s named checkTaxId. It’s searching a map, not making a guess.

The first index of a large repo takes a minute, then stays current as you edit. Semantic search is why the Agent can find the three files relevant to your task without you naming them — but @-referencing files explicitly is still faster when you already know where the change lives. If your codebase touches sensitive data, be deliberate about what gets embedded; the same discipline you’d apply to any tool that reads your source applies to what you let an editor index. Context handles the “what”; Rules handle the “how.”

Rules: encode your team standards so you don’t repeat yourself

Cursor lets you define Rules — persistent, project-level instructions the AI follows so you don’t restate your standards in every prompt. “Use pnpm, not npm.” “All API handlers return the shared ApiError type.” “No any; prefer explicit types.” You write these once and Cursor applies them across Tab, Cmd+K, chat, and the Agent.

Rules live in your project, versioned with the code, so the whole team inherits the same guardrails. This is the difference between a demo and a production setup: without Rules you re-teach the AI your conventions every session; with them, its first draft already matches your house style. If you also use MCP to connect the editor to internal tools, my guide on connecting an AI agent to your data with MCP pairs naturally with Rules — one encodes behavior, the other encodes access. Rules are model-agnostic, handy because Cursor lets you swap models freely.

Picking a model: multi-vendor (Claude, GPT, and more)

Cursor is multi-vendor — you pick the model per request from a menu that includes Claude and GPT models, among others. There’s no single hardcoded brain; you choose based on the task. I reach for stronger reasoning models on gnarly multi-file refactors and faster models for routine edits, and the model picker sits right in each AI surface so switching costs nothing.

The versions on offer change constantly, so don’t memorize a model name — check the picker for what’s current. What matters is the pattern: the same @ context and the same Rules apply no matter which model you select, so you can benchmark models against your real work without changing anything else. To call these models directly from your own code outside the editor, my walkthrough of how to use the Claude API covers that path. With context, Rules, and a model chosen, you’re ready for a real task.

Your first real task: an end-to-end Cursor AI workflow

Here’s the loop I actually run. Open the project, let the index finish, then drive a feature from one surface to the next:

1. Cmd+L (chat): "@codebase where do we handle Stripe webhooks?"
2. Cmd+I (Agent): "Add a handler for invoice.payment_failed in
   @file src/webhooks/stripe.ts, log it, and add a test."
3. Review the multi-file diff the Agent proposes; accept or refine.
4. Tab: as you tweak the generated code, accept predicted edits.
5. Cmd+K on a rough block: "add retry with exponential backoff."

Notice the division of labor: chat to orient, the Agent for the multi-file heavy lift, Tab to move fast through cleanup, and Cmd+K for one surgical rewrite. Rules keep the generated code in your house style, and @ references keep the AI pointed at the right files. This is the same discipline that separates a reliable agent from a flaky one, and it’s what turns Cursor AI from autocomplete-with-vibes into a real part of your production workflow.

Pricing: Free, Pro $20, Pro+ $60, Ultra $200, Teams $40 (usage-credit)

Cursor uses a usage-credit model: your monthly fee includes a pool of credits, and overages are billed after you exhaust them. As of 2026 the tiers are Free; Pro at $20/mo; Pro+ at $60; Ultra at $200; and Teams at $40/user. Confirm the current numbers at cursor.com/pricing, since both prices and the credit math get tuned over time.

Cursor vs Claude Code — and running Claude Code inside Cursor

It’s tempting to frame this as Cursor versus everything else, but the honest answer is that Cursor and Anthropic’s terminal agent, Claude Code, are complementary — not strictly either/or. Claude Code ships a Cursor extension, so you can run it inside Cursor and get a terminal-first agent alongside Cursor’s four surfaces. I keep both open: Cursor for editor-centric work, Claude Code for terminal-, CI-, and script-shaped tasks.

For the deep comparison, read Claude Code vs Cursor; if you’re new to Anthropic’s tool, start with what Claude Code is and how to use it. For everything AI-agent on this site, the AI agents hub is the map. The takeaway for Cursor is simple: learn the four surfaces, feed the AI real context with @ symbols, and encode your standards as Rules — and Cursor stops being autocomplete-with-vibes and becomes a real part of your production workflow. Full docs live at cursor.com/docs.