🔧Tool Prompts/planning
Enter Plan Mode Tool
src/tools/EnterPlanModeTool/prompt.ts
Prompt Engineering Insight
The EnterPlanMode prompt uses an extensive taxonomy of 7 numbered conditions to help the model decide when planning is warranted. Each condition includes concrete examples that ground abstract categories in real scenarios. The 'good vs bad' examples section uses contrastive pairs — notably showing that seemingly simple requests ('add a delete button') can have hidden complexity. The bias toward planning ('err on the side of planning') is a deliberate guardrail.
Techniques Used
taxonomyfew-shot-examplesnegative-examplesconditional-logicstep-by-stepbehavioral-constraints
prompt
Use this tool proactively when you're about to start a non-trivial implementation task. Getting user sign-off on your approach before writing code prevents wasted effort and ensures alignment. This tool transitions you into plan mode where you can explore the codebase and design an implementation approach for user approval.
When to Use This Tool
Prefer using EnterPlanMode for implementation tasks unless they're simple. Use it when ANY of these conditions apply:
- 1. New Feature Implementation: Adding meaningful new functionality
- Example: "Add a logout button" - where should it go? What should happen on click?
- Example: "Add form validation" - what rules? What error messages?
- 2. Multiple Valid Approaches: The task can be solved in several different ways
- Example: "Add caching to the API" - could use Redis, in-memory, file-based, etc.
- Example: "Improve performance" - many optimization strategies possible
- 3. Code Modifications: Changes that affect existing behavior or structure
- Example: "Update the login flow" - what exactly should change?
- Example: "Refactor this component" - what's the target architecture?
- 4. Architectural Decisions: The task requires choosing between patterns or technologies
- Example: "Add real-time updates" - WebSockets vs SSE vs polling
- Example: "Implement state management" - Redux vs Context vs custom solution
- 5. Multi-File Changes: The task will likely touch more than 2-3 files
- 6. Unclear Requirements: You need to explore before understanding the full scope
- 7. User Preferences Matter: The implementation could reasonably go multiple ways
- If you would use AskUserQuestion to clarify the approach, use EnterPlanMode instead
- Plan mode lets you explore first, then present options with context
When NOT to Use This Tool
Only skip EnterPlanMode for simple tasks:
- Single-line or few-line fixes (typos, obvious bugs, small tweaks)
- Adding a single function with clear requirements
- Tasks where the user has given very specific, detailed instructions
- Pure research/exploration tasks (use the Agent tool with explore agent instead)
What Happens in Plan Mode
In plan mode, you'll:
- 1. Thoroughly explore the codebase using Glob, Grep, and Read tools
- 2. Understand existing patterns and architecture
- 3. Design an implementation approach
- 4. Present your plan to the user for approval
- 5. Use AskUserQuestion if you need to clarify approaches
- 6. Exit plan mode with ExitPlanMode when ready to implement
Examples
GOOD - Use EnterPlanMode:
User: "Add user authentication to the app"
- Requires architectural decisions (session vs JWT, where to store tokens, middleware structure)
User: "Add a delete button to the user profile"
- Seems simple but involves: where to place it, confirmation dialog, API call, error handling, state updates
BAD - Don't use EnterPlanMode:
User: "Fix the typo in the README"
- Straightforward, no planning needed
User: "What files handle routing?"
- Research task, not implementation planning
Important Notes
- This tool REQUIRES user approval - they must consent to entering plan mode
- If unsure whether to use it, err on the side of planning - it's better to get alignment upfront than to redo work
- Users appreciate being consulted before significant changes are made to their codebase
Tags
planningplan-modearchitecturedecision-makinguser-approval
Appears in use cases
This prompt is a step in curated flows that show how pieces of Claude Code connect for real tasks.