docs/features/deep-planning.mdx
Deep Planning (/deep-planning) turns Cline into an architect before it becomes a builder. Instead of jumping straight into code, Cline systematically explores your codebase, asks targeted questions, and produces a detailed implementation plan — all before writing a single line.
Deep Planning follows a four-step process:
<Steps> <Step title="Silent Investigation"> Cline explores your codebase without asking you anything. It reads relevant files, traces dependencies, examines patterns, and builds a mental model of how your project is structured. You'll see Cline reading files and running searches during this phase.This step is intentionally silent — Cline gathers context first so it can ask better questions next.
For example, instead of asking "how should authentication work?", Cline might ask "I see you're using JWT tokens in `auth/middleware.ts` with refresh token rotation. Should the new endpoint follow the same pattern, or do you want session-based auth for this feature?"
Answer these questions to shape the plan. The more specific you are, the better the implementation plan will be.
- **Overview** of the feature and its scope
- **File-by-file changes** with specific descriptions of what to add, modify, or remove
- **Dependencies** between changes (what needs to happen first)
- **Edge cases** and error handling considerations
- **Testing strategy** for the implementation
The plan is saved as a markdown file you can review, edit, and share with your team before any code is written.
Type /deep-planning in the Cline chat input, followed by a description of what you want to build:
/deep-planning Add a notification system that sends email and in-app
notifications when users receive comments on their posts
The more context you provide upfront, the more focused the investigation phase will be. Include:
Once Cline generates implementation_plan.md, review it carefully:
Tell Cline about any adjustments before proceeding to implementation.
The deep planning prompt is optimized for each model family. Cline adapts its investigation and planning approach based on the strengths of whatever model you're using — whether that's Claude, GPT, Gemini, DeepSeek, or others.
This means you get effective deep planning regardless of your model choice, though stronger reasoning models will generally produce more thorough plans.
<Tip> Consider using a stronger reasoning model for the planning phase and a faster model for implementation. You can configure separate models for Plan and Act modes in Cline Settings. See [Plan & Act Mode](/core-workflows/plan-and-act#using-different-models-for-each-mode) for details. </Tip>Deep Planning works well with several other Cline features:
| Feature | How It Helps |
|---|---|
| Focus Chain | Tracks implementation progress against the plan with a visible todo list |
| Memory Bank | Preserves project context across sessions so deep planning has richer input |
| Plan & Act Mode | Use Plan mode for quick exploration, deep planning for thorough architecture |
| Checkpoints | Roll back implementation steps if something goes wrong during execution |
Both involve thinking before doing, but they serve different purposes:
| Plan Mode | Deep Planning | |
|---|---|---|
| Scope | Quick exploration and discussion | Thorough codebase investigation |
| Output | Conversation context | implementation_plan.md file |
| Best for | Medium tasks, understanding code | Large tasks, multi-file features |
| Duration | Minutes | Longer — depends on codebase size |
| Persistence | Lives in conversation history | Saved as a file you can reference later |
For most development work, starting in Plan mode is sufficient. Reserve /deep-planning for tasks where you'd normally spend significant time planning on a whiteboard before coding.
models/user.ts" gives a focused one.@ mentions to highlight key files in your prompt so the investigation phase starts in the right place.implementation_plan.md file is useful documentation even after the feature is built. Consider committing it or moving it to a docs folder./deep-planning on a feature you're unfamiliar with to get Cline to map out the codebase and explain how things connect.