How to Use Cursor: A Practitioner's Getting-Started Guide
Cursor is an AI code editor: a standalone application you install in place of your usual editor, with an AI agent, autocomplete, and codebase search built into the core of the workflow rather than bolted on as an extension. The first session is easy to start and free to try, but the parts that pay off most, indexing your codebase so the AI understands the whole project, learning when to lean on Tab versus the Agent, and choosing the right model for the job, are not obvious from the welcome screen. This guide walks the path: installing the editor, opening and indexing a project, using Tab and the Agent, picking a model, wiring up rules and MCP, and turning on Privacy Mode before your code leaves the machine.
Before anything else: Cursor is free to start. The Hobby plan needs no credit card and gives you a limited number of Agent requests and Tab completions. Paid plans begin at $20 per month and lift those limits. We cover what changes on paid plans below.
Before You Start
Getting into Cursor is quick. You download one application, sign in, and you are on the free Hobby plan with no card required. The thing to understand up front is that Cursor is not an extension you add to an editor you already use. It is its own editor, so the first step is installing it, not configuring a plugin.
One thing to settle early: if you do not want your code used to train models, plan to turn on Privacy Mode before you start working in real repositories. It is a setting you control, and on a team a single admin can enforce it for everyone. We walk through it in the last step.
Open and Index a Project
Open a folder the way you would in any editor, and Cursor begins building its codebase index. This is the feature that separates an AI editor from a chat window that happens to sit next to your code. The index is a codebase-wide semantic search, and Cursor describes the result as complete codebase understanding: the AI can find and reason about relevant code across the whole project, rather than seeing only the file you have open.
That matters because most real coding questions are not local. When you ask where a value is set, or to change how a feature behaves, the answer usually spans several files. Indexing is what lets the Agent and chat answer those questions accurately instead of guessing from the one file in view.
Practically, you open the project and let the initial index complete. After that, the AI features described below all draw on it, which is why the same prompt gives sharper results in an indexed project than in a folder you just opened.
Use Tab Autocomplete
The feature you will use most often is Cursor Tab. It is a specialized, fast autocomplete that predicts your next action and offers it as a suggestion you accept with the Tab key. What makes it different from ordinary autocomplete is that it does not just finish the current line. It predicts cursor jumps, meaning it anticipates where you are likely to move next and proposes the edit there, so you can move through a change by accepting one suggestion after another.
Tab is powered by Cursor's in-house Fusion model, which is tuned for this fast next-edit prediction rather than long-form reasoning. The right mental model is that Tab handles the small, mechanical edits, finishing a function, updating a call site, repeating a pattern across a block, while you keep your hands on the keyboard. When the change is larger or needs a plan, that is where the Agent comes in.
How to think about it: reach for Tab when you know roughly what you want to type and want it faster. Reach for the Agent when you would rather describe the outcome and let Cursor work out the edits across files.
Use the Agent
The Agent is the part of Cursor that does work for you from a plain-language instruction. You describe what you want, and the Agent searches the codebase, edits the relevant files, runs terminal commands, and carries out multi-step tasks, checking its own progress as it goes. Instead of writing every edit yourself, you describe the outcome and review the changes it proposes.
Running more than one agent at once
From Cursor 2.0, released October 2025, you can run multiple agents in parallel. Cursor keeps their work isolated using git worktrees or remote machines, so two agents working on the same project do not overwrite each other. This is how one developer can have several independent tasks in flight at the same time, with each agent operating on its own copy of the code.
For a first session, start with a single agent and a small, well-scoped task. Ask it to make a contained change you can read in a few minutes, review what it did, and accept or refine. Once you trust how it works, parallel agents and larger tasks follow naturally.
Step by step, end to end
Here is the loop the whole guide builds toward, from a fresh install to a working change.
| Step | What You Do |
|---|---|
| 1. Install | Download Cursor from cursor.com and sign in to the free Hobby plan |
| 2. Index | Open your project folder and let the codebase index finish |
| 3. Tab | Start typing and accept Tab suggestions for fast, small edits |
| 4. Agent | Describe a task in natural language and review the changes the Agent makes |
| 5. Model | Pick the model that fits the task, and add rules so Cursor follows your conventions |
Pick a Model and Set Rules
Cursor is not tied to a single AI provider. You choose between the frontier models from Anthropic, OpenAI, Google, and xAI, alongside Cursor's own in-house models: Composer 2.5, a low-latency agentic coding model, and Fusion, the model behind Tab. Many of the supported models also offer a Max Mode with up to one million tokens of context, which is useful when a task needs to consider a large amount of code at once.
Which one to pick is a per-task decision. The frontier models from the major labs tend to suit deeper reasoning and tricky changes, while Composer 2.5 is built for fast, agent-driven coding inside Cursor. The model list moves quickly, so rather than memorize it, check the current options in the model picker. The verified list as of June 9, 2026 included Anthropic's Claude 4.6 Sonnet and Opus 4.8, OpenAI's GPT-5.5 and GPT-5.3 Codex, Google's Gemini 3.1 Pro, and xAI's Grok 4.3, but treat the in-app list and the docs as the source of truth.
Rules and skills
Cursor can be shaped to match how you and your team work through rules, skills, and hooks: reusable instructions and behaviors that tell Cursor your conventions, so you do not have to restate them in every prompt. Teams can share these through a marketplace. Set up a small set of rules early, capturing the conventions you would otherwise repeat, and the Agent's output will line up with your project from the start.
On model names: the available models change often as providers ship new versions. Confirm what is currently offered in Cursor's model picker and the documentation rather than relying on any fixed list.
Connect Tools and MCP
Once the core loop feels comfortable, Cursor connects to the rest of your workflow. It supports the Model Context Protocol, an open standard for giving an AI tool access to external systems and data sources. Connecting MCP servers lets the Agent pull in context and act on tools beyond the editor, which is how Cursor reaches services you already use.
Alongside MCP, Cursor integrates with developer tools and platforms such as GitHub, GitLab, Slack, and Linear, so the AI can work with the systems where your code and tasks already live. Two integrations are worth calling out for newcomers.
- Bugbot is an agentic code-review tool that works with GitHub pull requests. It inspects the changes in a PR and surfaces issues, acting as an automated first-pass reviewer.
- The Cursor CLI brings Cursor into the terminal, including a headless mode suited to continuous-integration pipelines, so the same agent capabilities can run outside the editor window.
You do not need any of this on day one. Start with the editor itself, then add MCP servers and integrations as specific needs come up, rather than wiring everything before you have a reason to.
Turn On Privacy Mode
Before you point Cursor at real, private code, decide how you want your data handled. Cursor has a Privacy Mode you can switch on in settings. When it is enabled, Cursor guarantees that your code data is not used for training by Anysphere, the company behind Cursor, or by its model providers. On a team, an admin can enforce Privacy Mode for the whole organization, so individual developers do not each have to remember to set it.
For most individual developers, turning Privacy Mode on once and leaving it on is the simplest approach. For teams, treat it as an administrative control to be set centrally, the same way you would manage any policy that governs where source code is allowed to go.
Troubleshooting
These are the questions newcomers run into most often, with the practical answer for each.