Cursor for product managers: Ask, Plan and Agent as three separate jobs

What are Ask, Plan and Agent actually for?

Three modes, three jobs. Ask answers questions about your codebase without touching a file. Plan researches the code, asks you clarifying questions, and produces a written implementation plan you can edit before anything is built. Agent executes: it edits files, runs terminal commands, drives a browser, and keeps calling tools until the task is done, with no cap on how many calls that takes.

The instinct for a product manager new to the tool is that Agent is the point and the other two are preamble. That is backwards. The modes that change nothing are the ones that map onto work you already own, and the mode that changes everything is the one where you have the least ability to judge the result. Start where your judgment is strongest.

Ask is the mode a product manager should live in

The most common failure in a product spec is not a bad decision, it is a confident description of current behaviour that turns out to be wrong. Somebody remembers how the cancellation flow works, the memory is two releases stale, and the spec quietly assumes a state that no longer exists. Ask mode is the cheapest available fix: point it at the relevant files and ask what happens today, step by step.

Cursor's own learning material shows the same mode used for jobs that look nothing like writing code. Tag @Branch in a prompt and the agent gets the full diff of the current branch, which turns "review the changes on this branch" into a single question. The examples the docs give include asking what questions reviewers will have about a set of changes and what context the pull request description should carry. That is a product manager's job described in a developer's documentation, and it needs no code from you at all.

Two Ask prompts worth stealing directly. "Walk me through what happens when a user cancels during a trial, and name every place the subscription state changes." "What in this change is customer visible, and what is internal only?" Both produce answers you can check against your own product knowledge, which is the property that makes them safe to rely on.

Plan is where a vague request becomes a scope

Press Shift+Tab from the chat input to rotate into Plan Mode, or let Cursor suggest it, which it does on its own when a prompt carries keywords that signal a complex task. The agent then asks clarifying questions, researches the codebase, and generates an implementation plan you review and edit through chat or as a markdown file before clicking to build.

Cursor's own guidance on when to use it reads like a scoping checklist: complex features with multiple valid approaches, tasks that touch many files or systems, unclear requirements where you need to explore before you understand the size, and architectural decisions you want to review before they are made. For a quick change you have made a dozen times, going straight to Agent is fine. That distinction matters for a product manager because every item on the first list is a conversation you would otherwise have in a meeting with worse inputs.

Plans save to your home directory by default, and "Save to workspace" moves one into the project for future reference, team sharing, and documentation. That single click is what turns a disposable artifact into something you can paste into a ticket, argue about in a refinement session, and point at three weeks later when somebody asks why the change touched the billing service. The docs put it plainly: the hard part is often figuring out what change should be made, and once that is settled you can delegate the implementation.

Agent is the mode to use least and watch most

Agent lives in a sidepane at Cmd+I, and it is built from three parts: the instructions and rules guiding it, the tools it can call, and the model you pick. Its tools include searching the codebase, reading and editing files, running shell commands, controlling a browser to take screenshots and verify visual changes, and asking you clarifying questions mid-task while it keeps working.

The thing to internalise is Cursor's own advice about what to do when it goes wrong. Do not argue with an in-progress agent through follow-up prompts. Revert the changes, make the plan more specific about what you actually wanted, and run it again, which is usually faster and produces cleaner results. You can stop it mid-run with Cmd+Shift+Backspace the moment the diff view shows it heading somewhere you did not intend, rather than waiting politely for it to finish being wrong.

What does it cost, and is the free tier enough to find out?

Plan	Price per month	What changes
Hobby	Free	Limited Agent requests, no credit card
Pro	$20	Extended Agent limits, frontier models, MCP, skills and hooks
Pro+	$60	Three times the Pro Agent limits
Ultra	$200	Twenty times the Pro Agent limits, priority access to new features

Prices exclude applicable taxes, and annual billing takes 20 percent off. The free Hobby tier is genuinely enough to answer the question this page is about, because Ask and Plan are cheap compared to long Agent runs, and those are the two modes a product manager should be testing first. What the free tier will not support is a week of sustained agent execution, which is a fair place for the paywall to sit.

The honest limitation: you are not the stated audience

Building with Cursor names its audience without hedging: software developers, full-stack engineers, tech leads and engineering managers setting team standards, and product-minded developers building features end to end. Builders Camp's platform-wide FAQ states that no technical or coding skills are needed across the Membership generally, and that claim does not stretch to cover this tool. Cursor assumes you can read a diff, and every default is set for someone who can.

What that means in practice is narrower than it sounds. Ask and Plan produce prose, and prose is reviewable by anyone who knows the product. Agent produces diffs, and a diff is only reviewable by someone who reads code. If nobody on your side can do the second thing, the honest answer is to stop at Plan and hand it to an engineer, not to accept a change nobody evaluated.

Where the workflow gets taught, and what sits next to it

Building with Cursor runs 1 week across 2 live sessions of 90 minutes, taught by Tiago Pedro da Costa, Co-founder and CTO of Zumer, and covers the Ask, Plan and Agent workflow along with team configuration through AGENTS.md and rules files. It sits inside the Vibe Coding Expert Track alongside the paths for people who want to ship something rather than understand something.

If your goal is a working product rather than a better spec, Zero to Shipped with Vibe Coding is the shorter route: scope, build, ship, then iterate on feedback, with no assumption that you write code first. If you want the tool comparison before committing to any of them, the current field of AI tools for product managers covers what each category is actually for, and what vibe coding means covers the working style underneath all of it.

Run one Ask question against a feature you already own

The fastest way to find out whether this belongs in your week costs ten minutes. Open a repository you have shipped into, switch to Ask, and ask it to describe the current behaviour of a feature you wrote the spec for. Then compare the answer to what you believed on the way in. If they match, you have a fast verification tool. If they do not, you just found the reason to keep going.

See the Building with Cursor bootcamp

For the build-something path rather than the understand-something path, how to build a prototype with Cursor walks the full loop end to end, and GitHub Copilot for product managers covers the completion-first alternative sitting inside an editor your engineers may already use.