docs/guides/plan-mode-guide.mdx
Plan Mode prevents unintentional file modifications, letting you think through solutions and build confidence before committing to action. The core principle is understand before you change, giving you a research-first approach that prevents costly mistakes and creates better architectural decisions.
<Accordion title="Learn how to choose the right mode" icon="lightbulb"> <Columns cols={3}> <Card title="Chat Mode" icon="comments"> *Learn and discuss without changing code.***Mental Model:** Talking to a knowledgeable colleague
**Best For:** Explaining concepts, comparing approaches, code review discussions.
**Mental Model:** Architect surveying before renovation
**Best For:** Understanding a codebase, bug investigation, planning implementations.
**Mental Model:** Contractor executing approved blueprints
**Best For:** Implementing features, fixing bugs, running tests and commands.
Plan Mode excels in four key scenarios where understanding before acting prevents expensive mistakes:
<Columns cols={2}> <Card title="Codebase Exploration" icon="map"> Navigate unfamiliar systems and trace data flows without modification risk.[See exploration prompts →](#prompt-library)
[See analysis prompts →](#prompt-library)
Focus analysis on the user authentication module only, ignore the admin featuresAnalyze @Files and its direct imports for security issuesThis feature needs to handle Black Friday traffic (10x normal load). Plan accordingly.We're on AWS with strict security requirements. Plan a file upload system that meets SOC2 compliance.What could go wrong with this database migration? Plan rollback procedures.Show me 3 different approaches to implementing caching in this API, with pros and cons for each.You can switch to Plan in the mode selector below the chat input box.
| Tool | Available | Description |
|---|---|---|
| File/directory reading | ✅ | Browse and read any file or folder in your workspace |
| Grep/glob search | ✅ | Search for patterns across files and directories |
| Repository structure analysis | ✅ | Understand codebase organization and dependencies |
| Git history/diffs | ✅ | Review commits, branches, and changes |
| Web content fetching | ✅ | Access external documentation and resources |
| External API access | ✅ | Read-only calls to external services |
| MCP tools | ✅ | Model Context Protocol integrations |
| Database schema examination | ✅ | Analyze database structure (read-only) |
| File creation/editing | ❌ | Creating or modifying files |
| Terminal command execution | ❌ | Running shell commands |
| System modifications | ❌ | Changing system settings or configurations |
| Package installation | ❌ | Installing dependencies or packages |
| Git commits/pushes | ❌ | Making changes to version control |
| Database modifications | ❌ | Altering database data or structure |
Context is the foundation of effective planning. Without proper context, AI models fall back on generic patterns, leading to plans that don't fit your specific system. Continue's context system transforms broad suggestions into actionable strategies:
| Context Type | Usage | Best For |
|---|---|---|
| Highlighted Code | cmd/ctrl + L (VS Code) or cmd/ctrl + J (JetBrains) | Component-specific analysis |
| Active File | opt/alt + enter when sending request | Current file context |
| @Files | @Files package.json tsconfig.json | Specific file analysis |
| @Terminal | @Terminal | Debugging with output |
| @Git Diff | @Git Diff | Change impact analysis |
**Microservices Communication**:
`Analyze how our microservices communicate and identify potential bottlenecks in service-to-service calls.`
**Database Schema Review**:
`Examine the database schema and relationships to understand how user data is structured and accessed.`
**Technical Debt Assessment**:
`Analyze this codebase for technical debt hotspots and maintenance pain points.`
**Modernization Planning**:
`Assess this legacy system and recommend modernization opportunities that provide the highest impact with lowest risk.`
**Package Manager Migration**:
`Create a plan to migrate from npm to pnpm, analyzing dependencies and potential breaking changes.`
**Monorepo Conversion**:
`Plan how to convert our multiple repositories into a single monorepo using Nx or Lerna.`
**Payment Integration**:
`We need to add Stripe payments to this e-commerce app. Plan the integration considering our current architecture.`
**API Migration**:
`@Codebase - Plan a migration from REST to GraphQL across our entire API.`
**API Optimization**:
`Plan a performance optimization strategy for this Node.js API, focusing on database queries and caching.`
**Bundle Analysis**:
`Analyze this React app for performance bottlenecks. What are the most expensive operations?`
**Production Incidents**:
`@Git Diff We're seeing 500 errors in production. Analyze recent changes and identify what might be causing the issue.`
**Deployment Issues**:
`Our staging environment works fine, but production deployments fail. Analyze environment differences.`
**CDN Implementation**:
`Plan a CDN strategy for our global user base, considering asset optimization and edge caching.`
**Caching Strategy**:
`Show me 3 different approaches to implementing caching in this API, with pros and cons for each.`
**Threat Modeling**:
`Model potential security threats for this user registration flow and plan mitigation strategies.`
**Compliance Planning**:
`Plan GDPR compliance implementation for this user data handling system.`
Move to Agent Mode when you have:
✅ Clear understanding of the current system
✅ Detailed implementation plan with specific steps
✅ Risk assessment and mitigation strategies
✅ Team approval (if required)
✅ Success criteria defined
The three-mode system—Chat mode for learning, Plan mode for strategy, and Agent mode for execution—provides a complete development workflow that scales from simple bug fixes to complex system architecture.
Remember:
The best code is planned code.