A few weeks into working with my AI coding agent, I noticed something odd. I was in Cursor’s Plan mode — the read-only mode where the agent thinks with you before touching anything — and the agent said: “I just added that file.”
Wait. You added it? I thought we were planning.
That moment of confusion taught me more about how to work with AI than any tutorial.
Planning is a partnership, not a pause
Plan mode isn’t where I think alone while the agent idles. It’s where we — me and my agent — sketch options, surface trade-offs, and stress-test direction before execution locks us in. The AI brings breadth: it can search the codebase, compare patterns, and propose structures faster than I can type. I bring judgment: goals, constraints, taste, and the decision to accept or redirect. Planning mode is the stretch of the conversation where those two roles stay visible — neither side pretending the other isn’t there.
When that collaboration works, the plan isn’t a document nobody reads. It’s the shared picture of what “done” means, so Agent mode can run without constant course-correction. When it doesn’t work — when it feels like the agent is building while the UI still says “plan” — trust breaks down. That’s why the rest of this post is as much about human–AI clarity as it is about Cursor’s product modes.
What Plan mode actually is
Cursor has two primary modes: Plan and Agent. Plan mode is a product guardrail — the agent reads, searches, and proposes changes for your review before executing. Agent mode invites execution directly: file edits, terminal commands, the works.
The key distinction people miss: Plan mode reflects your intent when sending a message. It’s not a real-time lock on every tool call across a long thread. The agent can still reference files, run searches, and sometimes the language it uses — “I just added” or “here’s the updated version” — sounds like it built something, even when it hasn’t. Or occasionally, a follow-up turn executes after an earlier plan step was accepted, and the mode chip in the UI hasn’t caught up.
This isn’t a bug. It’s a subtlety. And once I understood it, I started using Plan mode far more deliberately.
The trust confusion that changed my workflow
On March 21st, 2026, I was reviewing a long session with my agent Lumen. I spotted turns where the assistant said “I just added” while the Plan mode indicator was still showing. It felt like the UI was lying to me.
It wasn’t. But the mismatch eroded my trust in the interface — and trust in the system matters more than trust in any single output. If I can’t tell whether the agent is thinking or building, I can’t make good decisions about when to intervene.
So we built our own convention. I created a workspace rule called agent-mode-signal.mdc that requires the agent to prefix every turn with either [Discussion] (read-only: questions, explanations, planning) or [Build] (edits, commands, anything that changes the workspace). An optional [Build complete] at the end of a heavy batch signals the edit run is finished.
This doesn’t replace Cursor’s Plan and Agent modes — it layers an explicit text signal on top. The insight from my journal that day: “Explicit beats inferred.” Saying “discussion only until I type execute” is clearer than relying on a mode indicator alone.
What planning-first looks like in practice
Since then, I’ve started using Plan mode for anything with real stakes — always as a back-and-forth, not a monologue. A few examples where the collaboration mattered as much as the mode:
Research before commitment. Last week I ran a product landscape research sprint — 35+ URLs from Gartner, Forrester, Sequoia, Stanford, NIST, OWASP, and others. The goal was to figure out what to build in the agentic AI space. I steered priorities; the agent fetched, summarized, and structured. Together we turned that into a landscape analysis and scored 10 product candidates before writing a single line of product code. The result: a clear architecture document for the top pick, with competitive positioning, risk analysis, and a 4-week MVP plan. If I’d jumped into Agent mode on day one, I’d have built the wrong thing — not because the agent can’t code, but because we hadn’t agreed on what to code.
Honest assessment before redesign. About a week into building my financial markets risk engine, I asked the agent a hard question: “How well do you think our risk profiling actually is?” We were in a planning conversation — no execution pressure, just evaluation. The honest answer: 10 weaknesses, 7 fixable. That conversation led to a complete redesign — FRED macro data, fundamental analysis, a 3-layer scoring system, confidence labels. The quality of the redesign was directly proportional to the quality of the planning conversation that preceded it.
Research before rewriting. When I enriched my blog posts with real stories from journals and project files, I didn’t start editing. I launched two exploration agents in parallel — one scanning journals and rules for AI collaboration details, another scanning project files for the PM building journey. They returned specific dates, real error messages, agent-log quotes, concrete metrics. Only then did I rewrite. The posts went from generic thought leadership to specific builder stories, and the rewrite was fast because the research was already done.
The tension that makes it work
One of the 13 principles my agent and I agreed on is: “Ideas deserve to become real — we are builders, not planners.” That sounds like it contradicts everything I just said. It doesn’t.
The point of planning isn’t to delay building. It’s to make building cheaper. Every minute spent in Plan mode — scoping what’s in and out, evaluating trade-offs, checking whether the current approach is actually good — saves multiples of that time in Agent mode. I’ve watched the agent happily build for hours on a direction that a five-minute planning conversation would have redirected.
The most expensive thing in AI-assisted development isn’t tokens or API calls. It’s building the wrong thing confidently and only realizing it when you try to use the result.
When I use each mode
After a few weeks of working this way, here’s where I’ve landed:
Plan mode for:
- Architecture decisions (static site vs live dashboard, risk engine layer design)
- Research sprints (market analysis, competitive positioning, technology evaluation)
- Evaluating trade-offs with real stakes (what to build, what to defer, what to kill)
- Reviewing what we’ve built honestly (“how good is this really?”)
- Structuring work before a build session (what files to touch, what order, what the acceptance criteria look like)
Agent mode for:
- Execution after a plan is clear
- Iterative building where the next step depends on the last output
- Quick fixes and small changes where the cost of undoing is low
- Deploying, committing, running tests
The boundary isn’t rigid. Sometimes I start in Plan, accept the direction, and switch to Agent mid-thread. Sometimes I start in Agent for a quick fix and realize the problem is bigger than expected — that’s when I slow down and move to Plan.
What I’d tell someone starting out
Most people skip Plan mode entirely. The agent can just do things — why would you add a gate? Because the gate is where the thinking happens. And thinking before building is the highest-leverage habit you can develop with these tools.
- Start sessions in Plan mode when you’re not sure what direction to go. Let the agent research, propose, and structure before it executes.
- Add your own signals if the mode indicator isn’t enough. A simple convention like
[Discussion]vs[Build]removes ambiguity about what’s happening in any given turn. - Ask the hard questions during planning. “How good is this?” and “What could go wrong?” are dramatically more useful before the code exists.
- Don’t plan forever. The goal is to build. Planning is the runway, not the destination. Ship something real — then plan the next iteration.
The best sessions I’ve had follow a rhythm: plan together, build together, evaluate honestly, plan again. The planning keeps the building honest. The building keeps the planning grounded. Neither side does its best work in a vacuum — Plan mode is where that joint work is supposed to happen before the repo changes.
Planning mode is one piece of a larger workflow I’ve developed for AI-assisted building. For the full picture — including workspace rules, journaling, and the philosophy behind it — read Building With AI Agents. Questions? Get in touch.