The problem: five ways to ask for help, and nothing that tells you which to use
You have installed Cursor, opened your project, and in front of you there is a completion that appears as you type, a panel where you can talk to the assistant, a selection of code you can send to it, a menu of modes and a list of models. The practical question is not what Cursor can do, but which of these tools to pick for the task in front of you, and what to let it touch. This guide answers in this order: what Cursor is compared with VS Code, how you move from one to the other, how Tab, Agent and the modes are used in daily work, and where the security limits sit that are worth knowing before you give a command to an agent.
A word on why the text always cites the documentation and a date. Cursor is a third-party product that changes quickly: its interface, the names of its menus and its paid plans have changed several times within a year, and guides written before those changes describe things that no longer exist. Every feature below was re-read on 2026-11-13 against the official documentation and the changelog; what I could not find there is not included. Cursor was not installed on the machine I wrote this on, so the steps inside the editor were not tried here: I report them as the documentation describes them, and where it matters I say so.
What Cursor is, and what it takes from VS Code
The migration page says that Cursor is based on the VS Code codebase, and that this is why switching is painless: settings, keyboard shortcuts and look and feel are the ones you already know. One consequence that the official text states frankly is the version lag: Cursor is realigned regularly with the latest version of VS Code, but for stability it often uses a slightly older one. If a feature that just came out in VS Code is missing, this is the most likely reason.
Importing your VS Code profile
The import is a single click in Cursor Settings, under General, then Account, then "VS Code Import", and it brings across extensions, themes, settings and shortcuts. If you change machine or want more control, the manual route uses VS Code profiles: from the Command Palette you export the profile (to a file or to a GitHub Gist) and import it on the other side. Nobody promises that every single extension will work identically: the documentation talks about transfer, not guaranteed compatibility, so after the import open the two or three extensions you really depend on and try them before you remove them from VS Code.
One interface detail surprises people coming from VS Code: the strip of activity icons is horizontal, to leave room
for the chat. If you prefer it vertical, the documentation points to a single setting, to be added to
settings.json or searched for in the settings screen, followed by a restart.
{
"workbench.activityBar.orientation": "vertical"
}
The key workbench.activityBar.orientation is the one given in Cursor's documentation and the value
to use is vertical; I have not checked the other possible values. Without this line the default horizontal
orientation stays. The file was validated as JSON, but its effect on the editor was not tried here.
Tab, Agent and modes: the right tool for each task
The simplest way not to get lost is to match each tool to the size of the task. The Tab completion works on the line you are writing, the Agent on a whole task, and in between there are the selection sent to the Agent and the modes that change how much the Agent can do on its own. We go from the smallest to the largest.
Tab: the completion that predicts your next edit
Tab is Cursor's autocomplete and, according to the documentation, it relies on your recent edits, on the surrounding code and on linter errors. Suggestions appear in grey in front of the cursor: Tab accepts them in full, Esc or simply continuing to type rejects them, and Cmd/Ctrl with the right arrow accepts them one word at a time, useful when the suggestion is half right. It can change several lines, add missing imports and propose coordinated edits; after you accept one, a second Tab jumps to the next place where it expects you to intervene, even in another file.
If the suggestions get in your way, for example while you are writing a document, the Tab indicator at the bottom right lets you snooze it for a chosen time, turn it off everywhere, or disable it for certain file types such as markdown and JSON. The accept key is remapped by searching for "Accept Cursor Tab Suggestions" in the keyboard shortcuts.
Agent: a task from start to finish
The Agent opens with Cmd/Ctrl+I. You describe a result in natural language and it decides which files to read, which changes to make and how to verify them. The tools at its disposal, in the documentation, include searching files and folders, reading files (images too), editing, running commands in the terminal, searching the web, a browser to take screenshots and try out an application, and the ability to ask you questions while it works. The documentation also states that there is no limit on the number of tool calls in a single task: a badly defined task can therefore run for a long time and consume a lot of your plan.
To send the Agent a precise piece of code, select it and press Cmd/Ctrl+L or Cmd/Ctrl+K: the Agent opens with those lines already quoted in the message. If you have read older guides, note that Cmd+K used to open inline editing and the documentation says that flow has been replaced by this one. In the same way, the "Composer" of earlier guides is not a panel today: Composer 2.5 appears in the documentation as the name of a Cursor model.
Modes: how much the Agent can do on its own
You change mode with Shift+Tab or with the menu in the panel. The table lists the four that the documentation names, with what each one can do to your files.
| Mode | When to use it | Edits files? |
|---|---|---|
| Agent | New features, refactoring, bug fixes | Yes |
| Ask | Understanding code, exploring the architecture | No, read-only |
| Plan | Complex features whose approach you want to review first | Yes, after you approve the plan |
| Debug | Hard bugs that need runtime evidence | Yes |
Two facts from the documentation change the way you work. Each mode uses its own context, so switching mode opens a new context window: it is better to open a new chat when you change task, instead of dragging the previous conversation along. Project, user and team rules, on the other hand, apply in all four modes. The practical rule is to start from Ask when you do not know a piece of code, move to Plan for changes that touch many files, and keep Agent for tasks you can describe in one sentence; Plan Mode and background agents are covered in more depth in the fourth article of the series.
What the Agent sees: the context
In the panel, typing @ lets you choose what to attach to the message. The current entries in the documentation
are few, and they say a lot about how the product has changed.
@filenameor@folder/: a file or a folder; after a folder, the slash lets you descend into its contents.@Terminals: the output of the terminals, useful for making it read an error without copying it.@Chats: the context of a previous conversation.@Commitand@Branch: the diff of the uncommitted working state, or that of the whole branch against main.@Browser: the content of the built-in browser.
The same page warns you to use mentions when you know which files matter, and to skip them when you do not,
because the Agent finds the relevant files on its own with its own search. The entries @codebase,
@docs, @web and @definitions that you see in many tutorials are not in today's
list: the changelog of version 2.0 says that many explicit entries were removed from the menu because the Agent
can gather context by itself. The context is not infinite: the ring next to the text field shows how much
of the window is full, and when it is about to run out Cursor summarises the oldest parts of the conversation.
On code search the documentation describes an engine called Instant Grep, which builds and queries its own index on your machine; Cursor states that it does not upload paths or code to build a search index and that it does not keep embeddings of your codebase for this purpose. One point remains true that the same page spells out: when the Agent opens a file it has found, the content of that file can still enter the request to the model. Anyone looking for the explanation of semantic indexing in old articles should therefore consider it outdated.
What to leave out: .cursorignore
The .cursorignore file at the root of the project uses the .gitignore syntax and blocks
access to what it lists for the Agent, for Tab and for mentions with the at sign. There are three things to
know before relying on it. First: the documentation writes that the protection is not guaranteed one hundred per cent,
because of the unpredictability of models. Second: the terminal tools and the MCP servers used by the Agent are not
governed by this file, so a terminal command that reads that file, if you approve it, is not stopped by the exclusion.
Third: a list of default exclusions already exists, which includes the .env* files, lock files,
folders such as node_modules/, and even extensions such as *.csv and *.pdf: if a
CSV never shows up in the Agent's answers, this is the reason.
Since the syntax is Git's, the patterns can be tested with Git itself, as the documentation suggests.
The script below goes through a fixed list of paths and, for each one, asks git check-ignore -v
which line of the file hits it; the --no-index option is there because the test files are not
tracked. It must be run in a folder with an initialised repository, in which the content of
.cursorignore has been copied into .gitignore.
#!/bin/bash
# Use the contents of .cursorignore as .gitignore: git check-ignore -v says which line matches each path
cd "$1" || exit 1
for p in node_modules/x/i.js src/app.ts src/app.log .env key.pem public/index.html public/assets/style.css public/assets/logo.js; do
r=$(git -c core.excludesFile=/dev/null check-ignore -v --no-index "$p" | cut -f1 | sed -E 's/^\.gitignore:([0-9]+):/line \1: /')
if [ -z "$r" ]; then echo "$p -> not ignored"; else echo "$p -> $r"; fi
done
In the first test the public folder is ignored as a whole with public/* and you want to
let through only the index and one stylesheet. Read the output line by line: a line that starts with
! means the file was let through by that rule, while the number says which line
of the file made the decision.
node_modules/
*.log
.env
*.pem
public/*
!public/index.html
!public/assets/style.css
# Output of verify.sh (git 2.53.0, two identical runs):
# node_modules/x/i.js -> line 1: node_modules/
# src/app.ts -> not ignored
# src/app.log -> line 2: *.log
# .env -> line 3: .env
# key.pem -> line 4: *.pem
# public/index.html -> line 6: !public/index.html
# public/assets/style.css -> line 5: public/*
# public/assets/logo.js -> line 5: public/*
public/index.html gets through, but public/assets/style.css does not: line 5 excluded the
assets folder and Git no longer descends into an excluded folder, so the exception rule
on line 7 is not even consulted. This is the limitation that Cursor's documentation describes and that Git
documents for .gitignore: a file cannot be re-included if a folder that contains it is excluded.
A real case where you run into it is a configuration file that should stay visible inside a folder
that is otherwise ignored.
The fix is to re-include the folder and then exclude its contents file by file, and only after that
add the exception for the single file. With the second version style.css gets through and logo.js
stays excluded, as you wanted.
node_modules/
*.log
.env
*.pem
public/*
!public/index.html
!public/assets/
public/assets/*
!public/assets/style.css
# Output of verify.sh (git 2.53.0, two identical runs):
# node_modules/x/i.js -> line 1: node_modules/
# src/app.ts -> not ignored
# src/app.log -> line 2: *.log
# .env -> line 3: .env
# key.pem -> line 4: *.pem
# public/index.html -> line 6: !public/index.html
# public/assets/style.css -> line 9: !public/assets/style.css
# public/assets/logo.js -> line 8: public/assets/*
The test uses Git's engine, not Cursor's: it shows that the two patterns behave as the documentation describes, not that Cursor applies them identically in every case. If a file you need does not show up in the answers, this is the first check to make. After changing the file, always confirm with a question to the Agent that depends on that file.
What the Agent can do on its own, and what it cannot
The default limits are documented in the Agent security page, and they are worth knowing before the first real task. Reading files and searching the code does not require approval. Neither does editing the project's files: the changes are saved to disk immediately, with the exception of configuration files, which ask for your consent. Running commands in the terminal requires approval by default, and the Run Modes configuration lets you allow the ones you trust, from a simple list of allowed commands up to an automatic review classifier; the documentation itself calls them "best effort" protections, not a hard security boundary. Every connection to an MCP server requires approval, and after you have given it each individual tool call asks for its own.
There are two practical consequences. Since file changes are immediate, version control is your safety net: start from a clean working tree, so that the diff you see is only the Agent's. Then there are checkpoints, snapshots of the codebase that the Agent creates before major changes: with "Restore Checkpoint" you bring the files back to the state of that point, but the documentation warns that they are stored locally, separate from Git, that restoring does not remove the messages from the conversation, and that they serve only to undo the Agent's changes, not to replace a commit. The typical case is an exploratory refactoring that went wrong halfway: the checkpoint takes you back in a few seconds, the commit protects you the next day.
Several agents at once: worktrees and the Agents Window
With Cursor 2.0, released on 2025-10-29 according to the changelog, you can run up to eight agents in parallel on a single prompt, using Git worktrees or remote machines so that each works on an isolated copy of the code. A Git worktree is a second working folder of the same repository, on a different branch: two agents that touch the same file do not step on each other because they are not in the same folder. Version 3, from 2026-04-02, added the Agents Window, an agent-centred interface where you run many agents in parallel locally, in worktrees, in the cloud or over remote SSH; the classic editor remains available and you switch from one to the other from the Command Palette with "Open Agents Window" and "Open IDE".
Worktrees created from the interface are a feature of the Agents Window alone; in the editor you use the commands of the
Worktree Skills. A new worktree does not have your dependencies installed nor the .env file, and this is
the most common flaw: the agent starts and fails at the first test. For this reason the documentation provides the file
.cursor/worktrees.json, with a list of commands run in sequence in the newly created worktree.
{
"setup-worktree": [
"npm ci",
"cp $ROOT_WORKTREE_PATH/.env .env"
]
}
Three keys are accepted: setup-worktree-unix, setup-worktree-windows and the
generic setup-worktree, which acts as a fallback. Each one is a list of commands or the path of a
script; ROOT_WORKTREE_PATH is the variable with which the command reaches the original folder in order to
copy its .env. The file was validated as JSON but not tried in Cursor. The documentation
advises against linking dependencies with symbolic links, because they can cause problems for the main worktree, and
recommends a fast package manager such as pnpm or bun. From version 3.5, a limit of 25 worktrees per machine
(cursor.worktreeMaxCount) automatically cleans up the oldest ones.
Privacy and costs: what is worth knowing beforehand
When you use the artificial intelligence features, Cursor sends prompts and code context to the model providers. The data governance documentation says that with Privacy Mode on your code is never used for training, either by Cursor or by the model providers, and that the mode is on by default for Enterprise teams: on individual plans it is up to you to check it in the settings. Cloud Agents are the only feature that requires Cursor to keep your code: encrypted copies of the repositories, held temporarily and deleted when the task is finished. If your client forbids code outside their network, do not enable them.
Prices change and are tied to a broader subscription, so I report them only as a snapshot of the models and pricing page of 2026-11-13, to be rechecked before you decide. Payment is monthly unless stated otherwise, and prices are before tax.
| Plan | Price | Third-party models |
|---|---|---|
| Free | $0 | Not available |
| Plus | $8 a month | Not available |
| Premium | $30 a month | At API list price, from prepaid credit |
| Super | $100 a month | Same as Premium |
| Ultra | $200 a month | Same as Premium |
The fact that weighs in the choice is not the price, it is the models row: on the Plus plan the Agent uses only Cursor's models, at fixed settings, and it does not include third-party models such as Claude, GPT or Gemini, which from Premium upwards are paid for separately, on usage, from the prepaid credit. The earlier Hobby, Start, Pro and Pro+ plans are now "legacy" and continue for existing customers, with two monthly usage pools. The weekly cap renews every week and, when it runs out, you can wait, use the credit or move up to a higher plan. There is no time-saving figure I can give you: it depends on the task and on your review.
Frequently asked questions
How do I bring my VS Code settings into Cursor?
In Cursor Settings, General, Account, press Import at "VS Code Import": extensions, themes, settings and shortcuts are transferred. Alternatively you export a profile from VS Code and import it from the Command Palette.
Where did inline editing with Cmd+K go?
Cmd/Ctrl+K and Cmd/Ctrl+L, with some code selected, now open the Agent with those lines already quoted. According to the documentation the old inline editing flow has been replaced by this one.
Can I stop Cursor from reading certain files?
Yes, with a .cursorignore file at the root, which uses the .gitignore syntax. It does not govern terminal commands or MCP servers, however, and the documentation does not guarantee complete protection.
What you can do now
You can choose the tool according to the size of the task: Tab for the line, Agent for the task, Ask when you want to understand without risking changes, and Plan when the work touches many files. You can bring your profile from VS Code, keep sensitive files away from the Agent and verify with Git that your exclusions work, and you know why, without version control, an agent that saves straight to disk is a risk. The natural next step is to teach the Agent your project's conventions with rules, in the second article, and then to hand it whole tasks in the third. To see it all on a whole project there is the workflow on an Angular application, and to choose between Cursor and other tools the comparison in the series.
Sources
- Cursor, documentation: Quickstart - opening the Agent with Cmd/Ctrl+I, Plan Mode with Shift+Tab, consulted on 2026-11-13
- Cursor, documentation: Agent - the Agent's tools, no limit on calls, checkpoints that are local and separate from Git, consulted on 2026-11-13
- Cursor, documentation: Agent mode - Cmd/Ctrl+K and Cmd/Ctrl+L with a selection, the Agent, Ask, Plan and Debug modes and context per mode, consulted on 2026-11-13
- Cursor, documentation: Tab completion - accepting, rejecting, jumping to the next place, turning it off, consulted on 2026-11-13
- Cursor, documentation: Prompting agents - list of @ mentions and the context ring, consulted on 2026-11-13
- Cursor, documentation: Ignore file - .cursorignore syntax, default list, terminal and MCP limits, the limit on negation, consulted on 2026-11-13
- Cursor, documentation: Search - Instant Grep and search privacy, consulted on 2026-11-13
- Cursor, documentation: VS Code Migration - profile import, orientation of the activity-icon strip, VS Code version, consulted on 2026-11-13
- Cursor, documentation: Agent Security - default approvals for files, terminal and MCP, Run Modes, consulted on 2026-11-13
- Cursor, documentation: Worktrees - worktrees.json, setup keys, limit of 25 worktrees, consulted on 2026-11-13
- Cursor, documentation: Privacy and Data Governance - data flows, Privacy Mode, Cloud Agents, consulted on 2026-11-13
- Cursor, documentation: Models & Pricing - plans and prices, third-party models, legacy plans, consulted on 2026-11-13
- Cursor, changelog 2.0 (2025-10-29) - up to eight agents in parallel, @ entries removed, consulted on 2026-11-13
- Cursor, changelog 3.0 (2026-04-02) - Agents Window, consulted on 2026-11-13
- Git: gitignore - the rule on re-including a file in an excluded folder, consulted on 2026-11-13
The .cursorignore examples were run with Git 2.53.0 in a temporary folder outside the repository, twice with identical output: they show how the rules behave in Git, not in Cursor. The two JSON files were validated with Python. Cursor was not installed: everything about the editor, the Agent and the plans comes from the official documentation and the changelog read on 2026-11-13.

Commenti
Caricamento commenti...
Sign in to comment