All courses

Cursor . Intermediate . 64 min

Cursor for Teams

Get consistent results from Cursor across a team: pick the right mode for each change, encode conventions in project rules, give Agent precise context, and review cloud agent and Bugbot output with care.

What your team will learn

Outline

  1. Choosing a mode: Tab, Ask, Plan and Agent (16 min, 4-question quiz)
  2. Project rules in .cursor/rules (14 min, 4-question quiz)
  3. Precise context with @-mentions (16 min, 3-question quiz)
  4. Cloud agents, Bugbot and team conventions (18 min, 4-question quiz)
Assign this course to your team

Free lesson

Choosing a mode: Tab, Ask, Plan and Agent

Cursor is an AI code editor built on VS Code. It gives you several ways to involve the model, from autocomplete to an agent that edits many files and runs terminal commands. Picking the right one is the first thing a team should agree on. Agent for a one-word rename is slow and noisy. Hand-editing a cross-file feature means doing the agent's job yourself.

The options

  • Tab: autocomplete that predicts your next edit from recent changes, nearby code and linter errors. Press Tab to accept, Escape to reject, or Cmd+Right Arrow (Ctrl+Right Arrow on Windows and Linux) to take one word at a time. After you accept, pressing Tab again jumps to the next place it expects you to edit, sometimes in another file.
  • Ask: a read-only mode for questions. It searches and explains code but does not edit files.
  • Plan: Agent researches the codebase, asks clarifying questions and writes an implementation plan you can edit before any code changes. You then tell it to build.
  • Agent: edits multiple files, runs terminal commands, reads the errors and iterates. This is the default and fits most real tasks.
  • Debug: for tricky bugs that are hard to reproduce or understand. Agent adds logging, asks you to reproduce the bug, then uses that runtime data to make a targeted fix and removes the logging.

Open the Agent panel with Cmd+I (Ctrl+I on Windows and Linux) and press Shift+Tab in the input to rotate through modes. Each mode starts a fresh context, so begin a new chat when you change tasks rather than switching modes halfway through a long thread.

A decision rule

If you are typing and know what comes next, let Tab carry you. If you can point at the exact lines that need to change, select them and send them to Agent with a one-line instruction. If you have to find the lines first, or the change spans files, or it needs a test run to confirm it, give Agent the whole task. If you cannot yet say what the change should be, start in Ask. If you know the goal but the approach touches a lot of code, use Plan first and read the plan before anything is written.

Selected function, sent to Agent with Cmd+K:
  "Return early when items is empty and add a JSDoc comment."

Agent, whole task:
  "Add pagination to GET /api/orders using the cursor pattern in
   src/api/customers.ts. Update the client in src/lib/api.ts.
   Run pnpm test src/api and pnpm typecheck until both pass."

Plan, then build:
  "We need to split the billing module into invoices and payments.
   Propose a plan with the files you would move and the order of steps."
Example prompts at each size

Run modes: what Agent may execute

Agent runs terminal commands and MCP tools, and the run mode decides which ones need your approval. You set it in Settings, under Agents, then Approvals & Execution. Team admins can restrict which modes are available, and team settings override personal and project ones.

  • Auto-review, the recommended mode: allowlisted calls run straight away, other shell commands run in a sandbox when possible, and calls outside the sandbox go to a classifier that allows or blocks them.
  • Allowlist: only actions on your allowlist run without approval. An empty allowlist gives you the old ask-every-time behavior.
  • Run Everything: every tool call runs with no sandbox and no classifier. Treat it like handing someone your terminal.

The sandbox keeps workspace files writable while guarding paths such as .git/config, and you can tune its network policy in .cursor/sandbox.json in the project or ~/.cursor/sandbox.json for yourself. A reasonable team baseline is Auto-review or Allowlist, with test and lint commands allowlisted, and anything that installs packages, pushes to a git remote or calls an external service left to a human. Agree on it once and write it down, so nobody quietly runs Run Everything on a laptop with production credentials.

Undoing a bad run

Agent creates checkpoints before significant changes. Restore Checkpoint rolls the files back to an earlier message and leaves the conversation in place. Checkpoints are stored locally and separate from git, so they are an undo button for the session, not version control. Commit before a big task, and reject edits you do not want in the diff view before accepting the rest.

Exercise

Same task, different modes

  1. Pick a change that touches exactly one function. Select it, press Cmd+K, and describe the change in one line.
  2. Pick a change that touches three files and needs a test. Do it in Plan first, edit the plan, then let Agent build it with the test command in the prompt.
  3. Note the time spent and the number of corrections for each.
  4. Check which run mode you are on, and write a one-paragraph team rule covering which mode to use for which kind of change and which commands may run without approval.

Keep going with your team

The other 3 lessons, quizzes, progress tracking, due dates and certificates come with the Training add-on at $12 per learner per month.

Get started

Independent course. Not affiliated with or endorsed by Anthropic, OpenAI or Anysphere.