Cursor Plan Mode makes the agent research your codebase, ask clarifying questions and write an editable implementation plan before it changes any code. You switch to it with Shift + Tab in the Agent chat input (or /plan and --plan in the CLI), review and edit the plan, then click Build when the approach looks right.
This guide covers how to turn it on, what happens during a planning session, where plans are saved, when Plan Mode is worth the extra step and how it compares with Cursor's other modes. It is based on Cursor's Plan Mode docs, Plan mode help page and CLI docs, read on 24 October 2026.
What is Cursor Plan Mode?
Cursor's one-line definition: "Plan Mode creates detailed implementation plans before writing any code."
Normal Agent mode reads your request and starts editing. That works for small, clear tasks. For anything bigger, the agent can head in a direction you did not want, and you only find out after it has touched a dozen files. Plan Mode adds a checkpoint: the agent proposes the approach first, and nothing gets built until you approve it.
How do you turn on Plan Mode in Cursor?
In the editor:
- Open the Agent panel with Cmd + I on Mac or Ctrl + I on Windows and Linux.
- Press Shift + Tab in the chat input to cycle through modes until you reach Plan. You can also use the mode picker dropdown.
- Type your request and press Return.
Cursor may also suggest Plan Mode on its own. The docs say it "suggests it automatically when you type keywords that indicate complex tasks."
In the Cursor CLI, you have three options:
# start a session in Plan mode
agent --plan
# same thing, long form
agent --mode=plan
Inside a running CLI session, type /plan or press Shift + Tab, which rotates between Agent, Plan and Ask. Per the slash commands reference, /plan [prompt] can switch to Plan mode, show the current plan or submit a prompt in Plan mode.
What happens during a Plan Mode session?
The docs describe five steps:
- The agent asks clarifying questions to understand your requirements.
- It researches your codebase to gather relevant context.
- It creates a comprehensive implementation plan.
- You review and edit the plan through chat or the Markdown file.
- You click to build the plan when ready.
The clarifying questions are the part people skip in normal prompting. If you ask for "add rate limiting to the API," the agent might ask which routes, what limits and where state should live. Answering a few questions up front is cheaper than undoing an implementation built on a wrong guess.
The plan opens as a virtual file you can read and edit, so you can delete steps, reorder them or add constraints directly. When it reads right, click Build.
Where does Cursor save plans?
"Plans are saved by default in your home directory," according to the docs. Click Save to workspace to move a plan into your project "for future reference, team sharing, and documentation."
Saving to the workspace is useful when:
- A teammate will review the approach before you build it.
- The plan doubles as design notes for a pull request.
- You want to rerun or refine the same plan later.
When should you use Plan Mode?
Cursor lists four cases where Plan Mode works best:
- Complex features with multiple valid approaches
- Tasks that touch many files or systems
- Unclear requirements where you need to explore before understanding scope
- Architectural decisions where you want to review the approach first
For the rest, the docs are direct: "For quick changes or tasks you've done many times before, jumping straight to Agent mode is fine."
A rough rule: if you could write the change yourself in a few minutes, skip the plan. If you would sketch it on paper first, use Plan Mode.
What should you do when the build goes wrong?
Cursor recommends going back to the plan instead of patching the result with follow-up prompts: "Revert the changes, refine the plan to be more specific about what you need, and run it again. This is often faster than fixing an in-progress agent, and produces cleaner results."
In the editor, the help page describes the steps:
- Find the Revert button in the bottom right of an earlier chat message.
- Click Revert, then Confirm to roll your files back to that point.
- Make the plan more specific and run it again.
The docs add that for larger changes, the hard part "is often figuring out what change should be made." Time spent tightening the plan usually pays back in a cleaner build.
How does Plan Mode compare with Cursor's other modes?
| Mode | What it does | Edits files? |
|---|---|---|
| Agent | Works through the task with tools: search, edit, terminal | Yes |
| Plan | Asks questions, researches and writes a plan you approve, then builds it | Only after you click Build |
| Ask | Explores code and answers questions | No |
| Debug | Forms hypotheses, adds logging and uses runtime evidence to find a root cause before fixing | Yes, to add logs and the fix |
Ask mode, per the CLI docs, lets the agent search "your codebase and provides answers without editing files." Debug Mode is aimed at bugs you can reproduce but cannot explain. Cursor also supports Custom Modes, where a skill stays in context on every turn until you exit the mode, which suits playbooks like a team's planning checklist.
How is Cursor Plan Mode different from Claude Code plan mode?
The idea is the same: research and propose, then implement once you approve. Both use Shift + Tab to get there. The details differ. Cursor adds clarifying questions as an explicit first step, saves plans to your home directory with an option to move them into the workspace, and starts the build with a Build button. Claude Code's version is part of its permission modes. See the Claude Code plan mode guide for how it works there.
Tips for better plans
- State constraints up front. Name the files, libraries or patterns to use or avoid. Cursor rules can hold the ones that apply to every task.
- Answer the questions properly. Short, vague answers lead to vague plans.
- Cut scope in the plan, not the code. Removing a step from the plan is easier than reverting it later.
- Save plans you will reuse. A saved plan is a record of why the code looks the way it does.
Keep your planning prompts
If you find a planning prompt or checklist that works, keep it somewhere you can reuse it in Cursor, Claude Code or Codex. Kipt stores prompts and Agent Skills as Markdown in a private GitHub repo you own, with tags and Cmd+K search. The writing plans skill is one example of a planning playbook packaged as a skill.