Cursor is an AI code editor built on a fork of VS Code, designed so AI assistance sits inside the editing loop rather than beside it. Instead of switching to a separate chat window to draft code, you get inline completions as you type, plus an agent that can plan and execute multi-file changes with your review at each step. If you want a broader hands-on introduction, our Cursor overview covers the editor in more depth. This article focuses on how the main AI features fit together and what your first session should look like.
Who Cursor is for
Cursor is a good fit if you meet most of these criteria:
- You spend real hours writing or maintaining code and want AI embedded in that work, not bolted on.
- You want assistance that considers project context — related files, conventions, structure — rather than just the visible file.
- You already use VS Code and want to keep your extensions, themes, and keybindings. Setup offers to import them.
- You prefer reviewing concrete diffs over copying suggestions from a chatbot.
It is a weaker fit if you rarely edit code, or if your environment forbids sending code to cloud-based models — more on that boundary below.
How the workflow differs from a conventional editor
A conventional editor treats AI, if present, as a passive helper. Cursor treats it as a collaborator with two modes: Tab handles the moment-to-moment editing, while Agent handles delegated tasks that span files, searches, and terminal commands run with your approval. You stay in the reviewer’s seat either way: changes arrive as diffs you accept, reject, or refine, and the feedback loop runs through your own tests and builds rather than the model’s confidence.
Agent and Tab at a glance
The two features are complementary, not competing. Exact capabilities and model behavior can vary by plan, account, and current documentation, but the interaction models differ consistently:
| Aspect | Tab | Agent |
|---|---|---|
| When it acts | While you type | When you assign it a task |
| Typical scope | The current edit, including multi-line suggestions | Multi-file changes, codebase searches, terminal commands |
| Interaction | Inline suggestions you accept or dismiss | Conversational request, then edits you review |
| Your role | Steer keystroke by keystroke | Specify the outcome, review diffs, iterate |
| Good fit | Repetitive edits, in-place refactors, boilerplate | Multi-step tasks that cross several files |
A practical rule: if you can describe the change in one sentence about where and what, Tab territory. If it needs a plan, multiple files, or a search first, use Agent.
A first-session workflow
This mirrors the official quickstart; our getting-started guide walks the same path in more detail.
- Install and sign in. AI features require a Cursor account. If prompted, import your VS Code extensions, themes, keybindings, and settings.
- Open a small, familiar project that is under version control with a clean working tree.
- Warm up with Tab. Make a repetitive edit — rename a variable used several times, or duplicate and adapt a small function. Accept suggestions with Tab, dismiss with Escape, and note when it proposes multi-line changes.
- Give Agent one scoped task. For example: “Add input validation to the signup form and update the related tests.” If you want to see the approach before edits land, ask it to outline a plan first.
- Review everything. Read each diff, run your tests or build, then keep or revert changes file by file.
- Tune the loop. If results miss context, mention specific files explicitly. For recurring conventions, standing instructions via project rules help — see rules for getting started.
Limits and boundaries
Set expectations before relying on it:
- Usage allowances differ by plan and can change, so treat heavy daily agent use as subject to whatever your current plan permits. Nothing here should be read as an unlimited-use guarantee.
- Available models vary by account and region and change over time; check in-app rather than assuming any particular model.
- Agent quality depends on the context it receives. On large or unusual codebases, it can misread structure — scoped tasks outperform broad ones.
- Both Tab and Agent can produce plausible-but-wrong code. Reviewal is not optional.
Privacy and security boundaries
AI features work by sending relevant code and context to models to generate results — that is the core trade-off to understand. Options such as privacy mode, where offered on your setup, are designed to prevent your data from being used for training. On team and enterprise plans, administrators may control data-handling settings and defaults, and regional requirements can apply. Before pointing Cursor at sensitive or proprietary code, review the privacy settings available to you and your organization’s policies, and confirm current behavior in the official documentation, since defaults and options evolve.
Verification and recovery
Treat every output as a proposal. Three layers of verification and recovery:
- Review diffs before accepting, and reject per-change in the Agent’s review rather than untangling edits afterward.
- Use checkpoints. Where available, Agent creates restore points you can roll the workspace back to if an edit sequence goes sideways.
- Keep git as the ground truth. Commit or stash before delegating tasks, run
git diffyourself, and never approve terminal commands blindly — read each one, and run it manually if you are unsure.
Troubleshooting
- Agent makes vague or wrong edits. Restate the task with target files and expected behavior, split it into smaller steps, and point it at specific files rather than the whole repo.
- Agent repeats a mistake. Paste the exact error or failing test output into the conversation, and codify the convention in rules if it recurs.
- Tab suggestions are missing. Confirm Tab is enabled in settings, that you are signed in, and that your setup supports it — behavior can vary by model and configuration.
- Behavior differs from this article. Features change; the current official documentation always wins over any snapshot, including this one.
FAQ
Is Cursor an editor or an extension?
It is a standalone editor built on a fork of VS Code. Onboarding can import your existing extensions, themes, keybindings, and settings, so most VS Code muscle memory carries over. Compatibility with every specific extension is not guaranteed — verify the ones your workflow depends on.
Do Tab and Agent use the same AI models?
They are separate features with different interaction models, even though both are AI-powered and model selection can overlap. Which models are available depends on your plan, account, and region, and changes over time — check the in-app model list for what applies to you today.
Does Cursor train on my code?
Features send relevant code and context to models to produce results. Privacy mode, when enabled and available on your plan, is designed to stop your data from being used for training. Administrators and regional settings can affect what applies to you, so confirm against the current privacy documentation.
Can I try it without risking my project?
Yes. Work on a fresh branch or a throwaway clone, assign small scoped tasks, review every diff, and avoid blanket command approvals. Between per-change rejections, checkpoints where available, and git itself, you have multiple ways to undo an experiment cleanly.