deep-plan is a Claude Code plugin with 1 hand-picked skill, indexed on Flowy in the Product category.
> /plugin marketplace add piercelamb/deep-plan> /plugin install deep-plan@piercelamb-plugins
Blog posts:
- Building /deep-plan - The story behind this plugin
- The Deep Trilogy - How the three plugins work together
- What I Learned - Technical lessons from plugin development
/deep-plan transforms vague feature requests into detailed, production-ready implementation plans through AI-assisted research, stakeholder interviews, and multi-LLM review.
/deep-implement, its companion plugin, takes these section files and implements them with TDD methodology, integrated code review, and atomic commits.
For large projects with broad, vague requirements, use /deep-project first to decompose into focused planning units before running /deep-plan on each.
This plugin started as an effort to automate the most time-intensive part of my Claude Code workflow that I had previously been doing manually. It is primarily targeted at Claude Code users that don't have strict token constraints and prefer deep planning/plan review before implementation. It's designed to speed up creating production-ready code within Claude Code without sacrificing an understanding of how it works.
/plugin marketplace add piercelamb/deep-plan
/plugin install deep-plan
/plugin enable deep-plan
/deep-plan @planning/auth-spec.md
deep-plan orchestrates a comprehensive planning workflow that ensures you think through implementation details before writing code:
Research → Interview → External LLM Review → TDD Plan → Section Splitting
The plugin guides you through:
By the end, you have a complete planning directory with specs, research, reviews, and small, isolated implementation sections that any engineer (or Claude) can pick up cold.
This plugin is part of a three-plugin pipeline for turning ideas into production code:
/deep-project (decompose) → /deep-plan (plan) → /deep-implement (build)
┌───────────────────────────────────────────────────────────────────┐
│ THE DEEP TRILOGY │
│ From Vague Idea to Production Code │
├───────────────────────────────────────────────────────────────────┤
│ │
│ "I want to build a SaaS platform" │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ /deep-project │ │
│ └─────────────────────────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 01-auth │ │ 02-bill │ │ ... │ │
│ │ spec.md │ │ spec.md │ │ │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ /deep- │ │ /deep- │ │ ... │ ◀── YOU ARE HERE │
│ │ plan │ │ plan │ │ │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ ▼ │
│ ┌────┐┌────┐┌────┐┌────┐┌────┐┌─────────┐ │
│ │ 01 ││ 02 ││ 01 ││ 02 ││ 03 ││ ... │ │
│ └────┘└────┘└────┘└────┘└────┘└─────────┘ │
│ │ │ │ │ │ │ │
│ └─┬──┘ └──┬──┴────┘ │ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐ ┌─────────┐ │
│ │ /deep- ││ /deep- │ │ ... │ │
│ │implement││implement│ │ │ │
│ └─────────┘└─────────┘ └─────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐ ┌─────────┐ │
│ │ auth ││ billing │ │ ... │ │
│ │ code ││ code │ │ │ │
│ └─────────┘└─────────┘ └─────────┘ │
│ │ │ │ │
│ └──────────┴──────────────────┘ │
│ │ │
│ ▼ │
│ Production Codebase │
│ │
└───────────────────────────────────────────────────────────────────┘
| Plugin | Purpose | Input | Output |
|---|---|---|---|
/deep-project | Decompose | Vague requirements | Focused spec files |
/deep-plan | Plan | Spec file | Section files with TDD |
/deep-implement | Build | Section files | Production code |
Where to start?
/deep-project/deep-plan/deep-implementYou: "Claude, build me an auth system"
Claude: *immediately starts coding*
Result: Multiple iterations, missed requirements, rework
You: "/deep-plan @planning/auth-spec.md"
deep-plan: Research → Interview → External Review → TDD Plan → Sections
Result: Complete implementation plan reviewed by multiple LLMs, split into chunks that keep the context window monsters at bay
Time Investment: ~30 minutes of interview + review Time Saved: Hours of rework and missed requirements
Use deep-plan when:
Skip deep-plan when:
TL;DR: Create a spec file, run the command, answer questions.
1. Create a spec file:
Option A: Use your editor — Create planning/auth-spec.md with your feature description.
Option B: Command line:
mkdir -p planning
cat > planning/auth-spec.md << 'EOF'
# Authentication Feature
Add OAuth2 login with Google and GitHub providers.
Store sessions in Redis. Use JWT for API authentication.
EOF
Spec files can be as dense or as sparse as you like. I've used /deep-plan with a few bullet points and also used it with structured, thorough documents.
2. Run deep-plan:
/deep-plan @planning/auth-spec.md
3. Follow the prompts through Research → Interview → Review → Output
That's it. Your planning directory will contain a complete implementation plan with TDD stubs and parallelizable sections.
Token & Cost Note: This workflow is token-intensive (research, multi-turn interview, review). Run
/compactbefore starting. If using external LLM reviews (Gemini/OpenAI), those will incur API costs on your accounts.
If you /compact or exit in the middle, /deep-plan can recover from the existing files.
┌─────────────────────────────────────────────────────────────────┐
│ deep-plan workflow │
├─────────────────────────────────────────────────────────────────┤
│ │
│ /deep-plan @spec.md │
│ │ │
│ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Research │ ──▶ │ Interview │ ──▶ │ Spec │ │
│ │ (optional) │ │ (5-10 Q&A) │ │ Synthesis │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Section │ ◀── │ TDD Plan │ ◀── │ External │ │
│ │ Splitting │ │ Generation │ │ LLM Review │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ sections/section-01-*.md sections/section-02-*.md ... │ │
│ │ (Self-contained, parallel-ready implementation units) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
View @piercelamb’s profileBlog posts: The Deep Trilogy - How the three plugins work together What I Learned - Technical lessons from plugin development /deep-project transforms vague, high-level project requirements into well-scoped planning units through AI-assisted interview and
@piercelambBlog posts: The Deep Trilogy - How the three plugins work together What I Learned - Technical lessons from plugin development /deep-implement is the final step in the deep planning pipeline.
@piercelambdeep-plan is a Claude Code plugin with 1 hand-picked skill, indexed on Flowy in the Product category. Install it with the command on its page. It includes deep-plan. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it