Plan mode

"Plan first, then execute" is a widely repeated best practice in agentic coding. For complex tasks, planning usually reduces iterations because you catch scope gaps and wrong assumptions before code changes begin.

Plan mode makes this approach practical: the agent proposes a plan, you refine it, and only then you proceed to implementation.

What a good plan contains

A useful plan is not a long essay. It is a checklist you can approve and later verify.

            ## Goal
            Restate the goal and constraints in your own words.

            ## Scope
            What is in and out of scope, including files, modules, and behaviors.

            ## Approach
            What the agent should change and where (files/symbols).

            ## (Optional) Risk notes
            Where the agent should expect edge cases, regressions, or tricky dependencies.

            ## Review checklist
            What the agent should review to confirm the result: tests to
            add or update, commands to run, etc.
        

When the plan looks correct, proceed to implementation. If the plan is vague, ask the agent to add file locations, smaller steps, and a clearer review checklist.

Planning iterations

Planning works best as a short loop. The agent proposes a plan, you ask clarifying questions, and the agent revises the plan until it becomes actionable.

Useful prompts during planning:

List the files or modules you expect to touch.
Break the change into small steps with a reviewable diff per step.
What are the risky parts and edge cases?
What should we check in review to confirm it works?

Once the plan matches your intent, proceed to implementation.

When planning is not necessary

You can often skip plan mode when the task is small, local, and low-risk. For example, fixing a typo, renaming a variable in one file, adjusting a constant, or making a tiny formatting change.

If you start without planning and the task expands, switch back to plan mode and re-align on scope and approach.

02 March 2026