If you want to know how to use Cursor without fighting the editor, the right starting point is a small repo, a low-stakes first task, and a working understanding of Plan Mode before you reach for the rest of the feature set. Cursor is a fork of VS Code with an agent that lives in the side panel and can read, search, edit, and run code in your repo. The first hour is mostly about unlearning the “type into the box, get code back” reflex and learning the difference between a chat, an Agent, and a Custom Mode.
This guide walks through how to use Cursor from a clean install to a real workflow. It covers the install paths on macOS, Windows, and Linux, the Agent basics, the Plan Mode discipline, the context controls that decide what the model actually sees, and the kinds of tasks where Cursor quietly beats the alternative of pasting code into a chat tab. It is grounded in Cursor’s current docs at cursor.com/docs and cursor.com/help, checked August 19, 2026.
What Cursor Is, And What It Is Not
Cursor is a code editor with an AI agent built in. The agent, the side-panel assistant that opens with Cmd+I, can search your codebase, read files, run shell commands, edit code, and check the web when a task needs it. There is no public cap on the number of tool calls a single task can make. That is the part worth understanding before you treat it like a chatbot.
The bit that surprises people is that the editor side is mostly VS Code. Your existing extensions, keybindings, and settings carry over. The AI layer is bolted on in a way that, if you ignore it, leaves you with a familiar editor. If you engage it, you get an agent that can take a five-step task and run it across files without a human in the loop for each step.
It is also not a hosted model. Cursor routes requests to whatever model you select in the chat input. The model picker at the top of the agent input cycles on Cmd /, and Cursor Settings > Models controls the default. Faster models handle exploration well. More capable models handle multi-file refactors. Switch mid-conversation when the task changes shape.
How to Use Cursor: Pick the Right Install Path
The first fork in how to use Cursor is the install path. The editor runs on macOS 12 and later, Windows 10 and later, and Linux. Pick the package your OS supports, not the one that has the slickest marketing screenshot.
On macOS, download the native .dmg from cursor.com/download, open it, and drag Cursor into the Applications folder. On Windows, run the .exe installer and follow the prompts. On Linux, the apt and dnf repositories are the documented preferred path, with AppImage as a fallback when your distro isn’t covered.
The Linux apt setup is the one most people copy-paste from a stale blog post. The current commands from Cursor’s quickstart are the ones to use:
# Add the Cursor GPG key
curl -fsSL https://downloads.cursor.com/keys/anysphere.asc | \
sudo gpg -o /etc/apt/keyrings/cursor.gpg - dearmor
# Add the Cursor repository
echo "deb [arch=amd64,arm64 signed-by=/etc/apt/keyrings/cursor.gpg] https://downloads.cursor.com/aptrepo stable main" | \
sudo tee /etc/apt/sources.list.d/cursor.list > /dev/null
# Update and install
sudo apt update
sudo apt install cursorThe same pattern works for Fedora and RHEL via the documented cursor.repo file. Once the editor is installed, which cursor confirms the CLI is on your PATH.
That gets you the cursor command on your PATH, an entry in your application launcher, and automatic updates. The AppImage is portable and fine for throwaway environments, but it doesn’t give you a desktop icon, autoupdates, or the CLI. For a daily driver, use the repository. If you’re learning how to use Cursor on a corporate laptop, the repository install is the one your IT department can sign off without a separate AppImage exception.
When the editor opens, sign in with a Cursor account. You can create one for free at cursor.com. Once you’re in, open a project folder with File > Open Folder. The agent is most useful against a real codebase, not an empty editor.
Your First Agent Task
The agent lives in the side panel. Open it with Cmd+I. The recommended first prompt, lifted from Cursor’s own quickstart, is a codebase orientation request:
Explain this codebase. Point me to the main entry points, key modules, and anything I should read before making changes.
The agent reads the relevant files and returns a summary. This is the cheapest way to get oriented in a new repo. It is also the moment where you start to see how Cursor consumes tokens. The context ring next to the prompt input shows how full the model’s window is. As the conversation grows, Cursor compresses older turns into a summary so newer turns still have room.
Once you understand the project, ask for a small improvement. The Cursor team’s framing is “good first tasks are low risk, like improving some copywriting or fixing small UI issues.” Resist the temptation to aim for the biggest refactor in the repo. The point is to learn the rhythm: prompt, watch the diff, ask the agent to run the project’s existing checks.
After the agent finishes, review the diff. Cursor’s diff view shows what changed. The agent can run the tests, type checker, lint, or build that the project already uses. Ask for that explicitly. If the agent needs to run a script, the default terminal profile is the first one Cursor finds. Set your preferred profile with Cmd/Ctrl+Shift+P, then “Terminal: Select Default Profile.”
How to Use Cursor Plan Mode for Real Work
The single most important learning in how to use Cursor is Plan Mode. Toggle it with Shift+Tab in the agent input. When Plan Mode is on, Cursor doesn’t write code immediately. It reads the codebase, asks clarifying questions, and produces a written plan. You approve the plan, then the agent starts to execute.
That approval gate is the discipline. Plan Mode isn’t a slower version of normal mode. It is the version of the agent that doesn’t surprise you with a fifteen-file edit. Use it whenever the task spans multiple files, when you don’t know the exact shape of the change, or when the cost of a wrong edit is higher than the cost of writing a paragraph.
The reinforcing behavior is the clarifying question. When the agent asks, answer it. Those questions are cheap. They are the agent’s way of avoiding an expensive mistake. The alternative is the agent guessing, which is how you end up with a refactor that quietly rewrites your test names.
The Cursor team suggests pressing Shift+Tab to toggle Plan Mode for bigger changes, multi-file work, or anything that needs approval before coding. That is the rule to internalize. Default to Plan Mode for anything that touches more than a couple of files. Use normal mode for the rest.
Checkpoints: Your Local Undo Layer
Cursor creates checkpoints automatically before significant changes. A checkpoint is a snapshot of all modified files. Click any checkpoint in the chat timeline to preview the files at that point. The Restore Checkpoint button on a previous request reverts everything to that state. If you’re still learning how to use Cursor and the agent makes a change you did not expect, the checkpoint is the first thing you should reach for. Don’t try to undo by hand.
Checkpoints live outside Git. They are useful for undoing agent changes specifically. Use Git for any version control you intend to keep. The checkpoints are a safety net for the “wait, what did the agent just do” moment.
The pattern that works is: let the agent do its work, skim the diff at each significant commit, click a checkpoint if the diff is wrong, and keep going. Don’t try to stop the agent mid-run unless you have to. The checkpoint is the right tool for that. When you’re figuring out how to use Cursor, this loop is what separates “I trust the agent” from “the agent keeps making me nervous.”
The Context Controls That Matter
The single biggest factor in how to use Cursor well is how much context the agent sees. The model has a fixed window. Every file you attach, every tool the agent invokes, every prior message counts. Cursor compresses older turns when the window fills up, but the better practice is to feed the agent the right context up front.
Type @ in the chat input to attach specific context. The completions support files and folders (@src/components/), terminal output (@Terminals), prior chats (@Chats), git diffs (@Commit (Diff of Working State) or @Branch (Diff with Main)), and the built-in browser (@Browser). Skip the @ mentions when you don’t know which files matter. Agent finds relevant files through its own search if you don’t tell it which ones to look at.
The context ring shows the breakdown. Hover a segment in the bar to highlight that category: system prompt, tools, rules, skills, MCP, subagents, summarized conversation, and the live conversation. When a category is eating too much of the window, fix the input. A long prior conversation is the usual culprit. Start a new chat when the topic changes.
For project-specific behavior, use rules. Rules are persistent instructions that follow the project. They live in the project and edit alongside the code. The depth of the rule set shapes how the agent behaves. A short, opinionated rule file beats a long, generic one.
Custom Modes: Use a Skill as a Long-Lived Mode
One of the highest-leverage features in how to use Cursor is Custom Modes. Type / in the chat input to invoke a skill. Pressing Enter attaches the skill to one message, and it fades as the conversation moves on. To keep the skill in context on every turn, press Option+Enter (Mac) or Alt+Enter (Windows) on the skill entry, or pick “Use as Mode” from the menu. The skill stays in context until you exit the mode.
The right use cases are work that the agent does repeatedly. A code-review checklist that you want the agent to hold while moving through several files. A team playbook like /tdd that stays active for an entire feature. A debugging flow that the agent runs every time you hit a stack trace. Custom Modes are how you turn a one-shot prompt into a working style.
Skills themselves are markdown files with a valid frontmatter block. The optional icon and color frontmatter fields style the mode’s badge inside the Agents Window. Custom Modes are available in the Agents Window and the CLI. The editor-level chat still respects the same skill files.
The Agents Window: When You Want to Run Things in Parallel
The Agents Window is Cursor’s agent-first interface. Open it with Cmd+Shift+P → Open Agents Window. Switch back to the editor with Cmd+Shift+P → Open IDE. You can leave both open at the same time.
The Agents Window is where you run work that doesn’t need a screen. Multi-workspace projects, parallel agents in the cloud, cloud subagents (/in-cloud) for long-running tasks, and worktrees for isolated Git checkouts all live in the Agents Window. The general-availability release of the Agents Window shipped with Cursor 3 on April 2, 2026. For the first two weeks after that, Enterprise admins could pace the rollout. After that period, everyone has access.
The simple rule: edit heavy work stays in the editor. Agent orchestration stays in the Agents Window. If you find yourself running five agents in parallel on a single repo, the Agents Window is the right surface. If you’re reviewing a seven-file diff, the editor is the right surface.
What to Skip on Day One
The features that look impressive on a demo are not the ones that change your daily workflow. @goal for long-lived objectives, queued messaging with Enter vs Cmd+Enter, immediate messaging with Cmd+Enter, and Steer a running agent are useful, but they are second-order improvements. The first-order improvement is learning to write a clear prompt, use Plan Mode for anything beyond a couple of files, and review the diff the agent produces.
If you already use another AI coding tool, the cross-reference is worth knowing. The same how to use claude code and how to use openai codex workflows apply to Cursor with the obvious swap of CLI vs editor. The agent window is closer to running an openai-codex style agent loop than a chat-style interaction. The difference is that the cursor agent sees the file you’re editing, the terminal, and the project rules at once, not just the messages you paste. For the testing side of the agent’s output, how AI agent safety testing actually works is the background.
The Real Workflow
Once the basics land, the workflow that earns its keep is the one that closes the loop. Open the repo. Run the agent with Plan Mode for the task. Review the plan, edit it, then approve. Let the agent run. Skim the diff. Ask the agent to run the project checks. Click a checkpoint if the diff is wrong. Commit the result.
The first dozen runs will feel slow. The prompt has to be specific. The plan has to be tough. The diff has to be read. That is the cost of being comfortable with the agent’s output. Once the rhythm is set, the agent handles the typing and the navigation. You handle the judgment. That is the way the editor is meant to be used.
If you’re starting from a clean install, the practical order is this: install via the platform-native package, sign in, open a real project, run Plan Mode on a small task, then spend a week on the diff and checkpoint loop. That is how to use Cursor the way the people who built it expect you to.
