Cursor bundles a lot of capabilities into one editor — autocomplete, inline editing, context-aware chat, an agent that can execute multi-step tasks, even agents that run in the cloud. The fastest way to learn it isn’t to memorize buttons; it’s to map each feature to the job you’re actually doing. This guide groups Cursor’s core features by intent: understanding code, writing and editing it, delegating larger changes, and verifying the results. Where behavior can vary by version, model, plan, or administrator settings, we flag it — and Cursor’s official documentation remains the source of truth for current details.
Match the feature to the job
Pick the smallest tool that fits the task. Bigger tools are more powerful but need more review.
| Your intent | Reach for | Boundary to know |
|---|---|---|
| Finish a line or small edit while typing | Tab | Suggestions only — it won’t answer questions or run tasks |
| Rewrite a specific block in place | Inline edit (commonly Cmd/Ctrl+K) | Local, targeted changes — not multi-file execution |
| Ask “how does this work?” | Chat in Ask mode with codebase context | Guidance, not edits |
| Plan and execute a multi-step change | Agent | Edits files and may run commands — review everything |
| Visually check a web app’s behavior | Agent with its browser tool | Availability varies by version; not a substitute for real tests |
| Delegate a long task while you’re away | Cloud agents | Run remotely; review the resulting branch or PR before merging |
If you’re still deciding whether Cursor fits your setup, our overview of Cursor covers the editor more broadly.
Reading and understanding a codebase
When your goal is comprehension, use chat in Ask mode with codebase context enabled. Cursor can search across your indexed repository and cite the files it drew from, so you can verify answers instead of trusting them. Use @ mentions to pin specific files, folders, or documentation into the conversation — this is the single best fix for vague or generic answers.
Decision rule: if you’d be annoyed by an edit right now, you want Ask mode, not the Agent. Note that codebase indexing may need to complete before answers are well-grounded, and indexing behavior can depend on your settings and workspace size.
Everyday writing and editing
Tab handles the flow: it suggests completions as you type, including multi-line edits, and often proposes the next location worth changing. Accept with Tab, ignore with Escape. The default shortcut can be customized, and suggestion quality varies with the selected model and your settings.
Use inline editing when you know what you want changed and where. Select code, invoke the inline edit shortcut, describe the change, and review the diff. Good candidates: renaming a variable across a function, adding a guard clause, converting a loop. If the change touches more than a couple of files or requires running anything, escalate to the Agent instead.
Multi-step tasks with the Agent
The Agent is Cursor’s delegation tool. Give it a goal and it can plan, edit files, and propose terminal commands to build, test, or run your project. Whether commands execute automatically or wait for your approval depends on your auto-run settings — review them before your first session.
A reproducible first example: open a small project and prompt, “Add input validation to the signup form, then run the existing test suite and summarize any failures.” Then work through three checkpoints:
- Review the plan — confirm the scope matches your intent before edits land.
- Review each diff — accept changes file by file, not in bulk.
- Review every command — especially anything that deletes, installs, or reaches the network.
Keep early tasks narrow. “Fix this failing test” succeeds far more reliably than “improve the codebase.”
Browser checks and cloud workflows
Recent versions add a browser tool that lets the Agent open a running web app, click through pages, and inspect the result so it can catch its own visual or functional mistakes. Availability and behavior can vary by version and platform, so treat it as a convenient smoke check — not a replacement for your actual test suite.
Cloud agents extend this: a task runs remotely in an isolated environment on its own branch and can produce a diff or pull request when finished. This is useful for longer or self-contained work, and it depends on plan, settings, and whether the feature is enabled for your account. The rule stays the same — nothing merges without a human reading the diff.
Safe first tasks and a verification checklist
If you’re following a fresh setup, our getting-started guide walks the basics. For first tasks inside the editor, start where mistakes are cheap:
- Ask Ask-mode questions about a file you already understand, then check its citations
- Use Tab for a half hour of normal typing before touching anything else
- Have the Agent add comments or documentation to a single file
- Have it write a unit test for an existing function, then run the tests yourself
- Fix one known failing test with a scoped prompt
Verification checklist for anything the Agent touches:
- Read the full diff before accepting — plausible-looking code can still be wrong
- Run your build and tests yourself; don’t rely on the Agent’s report alone
- Scan the terminal history for commands you didn’t expect
- Commit or checkpoint after each accepted stage so you always have a return point
Recovery is layered: reject unaccepted changes, restore to a previous checkpoint when the feature is available, and fall back to git, which remains your real source of truth regardless of what any tool does.
Limitations, privacy, and security
Be aware of four boundaries. First, context is finite — very large repositories or uncommitted changes may not be fully represented, which is why manual @ mentions matter. Second, models generate plausible errors; the Agent can confidently produce code that compiles but misbehaves. Third, commands run with your permissions on your machine, so approval settings are a security control, not a formality. Fourth, never paste secrets, credentials, or API keys into prompts.
On privacy: Cursor offers a Privacy Mode designed so your code and prompts aren’t used to train models, and team and enterprise administrators can enforce data-handling settings centrally. Exact behavior depends on your plan and admin configuration — confirm the current policy in the official documentation rather than assuming.
Troubleshooting quick fixes
- Weak or missing Tab suggestions: check that the feature is enabled in settings and try a different selected model.
- Generic chat answers: add specific files with
@mentions and confirm indexing has finished. - Agent looping or drifting: stop it, restate the task more narrowly, and point it at specific files.
- Failing commands: paste the error output back into the conversation — the Agent works best when it can read the failure directly.
- Behavior seems different from a tutorial: features and shortcuts change between releases; re-check the docs.
FAQ
When should I use Tab instead of inline editing or the Agent?
Tab for suggestions while you type, inline editing for a change you can describe and locate yourself, and the Agent when the task spans multiple files, needs commands run, or requires planning. Escalate only when the smaller tool clearly can’t do the job.
Does the Agent run terminal commands without asking?
That depends on your auto-approval settings. By default you should expect a review step, but if you enable auto-run, commands will execute without confirmation — read the settings carefully before turning that on, especially on projects with sensitive data.
Is my code used to train models?
With Privacy Mode enabled, Cursor is designed not to use your code or prompts for training. Team and enterprise admins can enforce additional controls, and exact terms vary by plan — verify against the current documentation for your account type.
Can cloud agents work while my machine is off?
Yes — that’s the point of remote execution. The agent runs in an isolated cloud environment on its own branch, and you collect the result as a diff or pull request later. You still need to review and merge the output yourself, and availability depends on your plan and settings.