The Deep Trilogy: Three Commands That Turn Vague Ideas into Real Code
You know the drill. You open Claude Code, type something like “build a JWT authentication system”, and Claude starts coding instantly. Five minutes later you have generated files, defined routes, implemented middleware. It looks good. It feels productive.
And then, three hours later, you realize it forgot the refresh token. That the folder structure doesn’t fit with the rest of the project. That there are three functions doing almost the same thing. That the most important business use case isn’t covered at all.
The problem isn’t Claude. The problem is that Claude started coding before understanding what it was building.
The Deep Trilogy solves this.
What is The Deep Trilogy
They are three plugins for Claude Code created by Pierce Lamb and published in February 2026. Each one covers a stage of the development process:
/deep-project— breaks down broad and vague ideas into concrete components, ready to plan/deep-plan— converts each component into a detailed implementation plan, with research, user interview, and review by multiple LLMs/deep-implement— implements code from each section of the plan with TDD, automatic code review and git workflow
They’re not independent plugins: they’re designed to chain together. The output of /deep-project feeds into /deep-plan, and the output of /deep-plan feeds into /deep-implement. It’s a complete, automated development pipeline.
The problem it solves
Most developers using Claude Code in an advanced way have already discovered that forcing a planning phase significantly improves the final code. The problem is that orchestrating that planning is tedious: researching the codebase, interviewing your own requirements, reviewing the plan with another LLM, dividing into implementable sections.
Pierce Lamb did it all by hand for months. The Deep Trilogy was born from automating exactly that.
How to install them
/plugin marketplace add piercelamb/deep-project
/plugin marketplace add piercelamb/deep-plan
/plugin marketplace add piercelamb/deep-implement
To take advantage of multi-LLM review (one of the most powerful features of /deep-plan), you need at least one external API key:
export OPENAI_API_KEY="your-key" # For review with ChatGPT
export GEMINI_API_KEY="your-key" # For review with Gemini
If you don’t configure any, /deep-plan uses an internal subagent for review anyway. It works, but loses the value of having a second external opinion.
The three commands, in detail
1. /deep-project — From vague idea to concrete components
When you have something too big or fuzzy to plan directly, /deep-project breaks it down into manageable parts.
/deep-project @planning/requirements.md
You pass it a file with your idea (it can be as vague as you want) and the plugin breaks it down into individual components, each with enough structure for /deep-plan to work on separately.
It’s the right entry point when you’re starting a new project or when a feature is too big to plan all at once.
2. /deep-plan — The heart of the pipeline
This is the most sophisticated of the three commands. It takes a component and executes a complete workflow:
- Research — reviews the existing codebase and does web search if necessary
- Interview — asks you concrete questions to clarify requirements you didn’t specify (with auto-generated single select/multi-select)
- External review — sends the plan to Gemini and/or ChatGPT to get feedback from another perspective
- TDD plan — generates test stubs before writing a line of code
- Sections — divides the plan into small, self-contained implementation units
/deep-plan @planning/01-auth/spec.md
When finished, you have a planning/ directory with all the generated documentation:
planning/
├── your-spec.md # Your original input
├── claude-research.md # Codebase and web research
├── claude-interview.md # Interview transcript
├── claude-spec.md # Synthesized spec
├── claude-plan.md # ★ The main plan
├── claude-plan-tdd.md # Test stubs
├── reviews/
│ ├── gemini-review.md # Gemini feedback
│ └── openai-review.md # ChatGPT feedback
└── sections/
├── index.md # Index of sections
├── section-01-*.md
├── section-02-*.md
└── ...
It’s worth clarifying what the author himself says: this plugin is not for those with token restrictions. /deep-plan consumes quite a bit of context. It’s a deliberate investment: ~30 minutes of interview and review in exchange for avoiding hours of rework and lost requirements.
3. /deep-implement — Disciplined implementation
The third plugin takes the sections directory generated by /deep-plan and implements them one by one:
/deep-implement @planning/sections/.
For each section:
- Creates skeleton modules so imports don’t fail during TDD
- Writes the tests first
- Implements the code
- Launches a separate subagent to do code review
- Updates the section document with current status
- Makes a commit with a message based on the section
The result: each commit has its associated documentation. The git history becomes a map of the project.
The philosophy behind the design
Something that distinguishes the Deep Trilogy from plugins like Ralph Loop (which aims for total autonomy) is a conscious design decision: keep the developer involved at the moments that matter.
During /deep-plan, interview questions are not optional or generic. They’re the moment where the plugin detects what you didn’t specify and asks you directly. The author considers this the most valuable point of the entire workflow.
The three plugins also support resume from interruption. If you run out of context, if you pause the work or simply close the terminal halfway through, you can pick up exactly where you left off:
/deep-project @planning/requirements.md # Resumes from the last checkpoint
/deep-plan @planning/spec.md # Detects existing artifacts
/deep-implement @planning/sections/. # Continues from the next incomplete section
```## When to Use It (and When Not To)
**You'll want to use it when:**
- You're starting a new project or complex feature from scratch
- The scope is too vague to plan directly
- You want a plan reviewed by multiple LLMs before coding
- Architecture matters and you want documentation that survives the project
**You probably don't need it when:**
- It's a repetitive and well-defined task (that's what Ralph Loop is for)
- You have token or cost constraints
- You already have a solid plan and just need Claude to execute it
---
## How It Fits in the Ecosystem
The Deep Trilogy doesn't exist in a vacuum. In comparisons with other plugins, it consistently appears alongside Superpowers and Code Review as part of the group that genuinely changes how you work with Claude Code, not just adding shortcuts to it.
The difference versus Superpowers is philosophical: Superpowers intervenes at the moment of coding, forcing Claude to plan before starting. The Deep Trilogy assumes that planning deserves its own complete process, separate from implementation.
They're complementary, not competitors.
---
## Quick Installation
```bash
# Add all three to the marketplace
/plugin marketplace add piercelamb/deep-project
/plugin marketplace add piercelamb/deep-plan
/plugin marketplace add piercelamb/deep-implement
# Install and enable each one
/plugin install deep-project
/plugin install deep-plan
/plugin install deep-implement
# Configure external LLMs (optional but recommended)
export OPENAI_API_KEY="your-key"
export GEMINI_API_KEY="your-key"
# Complete workflow
/deep-project @planning/requirements.md # Step 1: decompose
/deep-plan @planning/01-auth/spec.md # Step 2: plan
/deep-implement @planning/sections/. # Step 3: implement
The Deep Trilogy is for those who’ve already learned that letting Claude code without planning produces code that works in the moment but fails in context. If you’ve already reached that conclusion and are orchestrating your own planning workflow by hand, this is exactly what automates that process.
Resources: