Blog 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.
Blog 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
@piercelambFAQ
deep-implement is a Claude Code plugin with 1 hand-picked skill for development work, indexed on Flowy. Install it with the command on its page. It includes deep-implement. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
> /plugin marketplace add piercelamb/deep-implement> /plugin install deep-implement@piercelamb-plugins
Blog 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. It takes the section files generated by /deep-plan and implements them one by one with TDD methodology, integrated code review, and a structured git workflow.
Where /deep-plan produces the what and why, /deep-implement handles the how—methodically, with tests first and human-in-the-loop code review at each step.
For large projects, use /deep-project first to decompose vague requirements into focused specs, then /deep-plan each spec, then /deep-implement the resulting sections.
I built /deep-implement because after I'd automated my planning workflow through /deep-plan, I found myself executing the same steps over and over to actually implement the produced section files. Why not have Claude orchestrate it for me?
/deep-implement keeps the human in the loop through code review and managing context. In the future /deep-implement will look to provide even more automation.
/plugin marketplace add piercelamb/deep-implement
/plugin install deep-implement
/plugin enable deep-implement
/deep-implement @planning/sections/.
deep-implement orchestrates a disciplined implementation workflow:
Read Section → TDD Implementation → Code Review → Interview → Commit → Next
For each section from /deep-plan, the plugin:
By the end, you have production-ready code with a git history that tells a clear story—and section documents that serve as living documentation of what was actually built, not just what was planned.
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- │ │ ... │ │
│ │ plan │ │ plan │ │ │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ ▼ │
│ ┌────┐┌────┐┌────┐┌────┐┌────┐┌─────────┐ │
│ │ 01 ││ 02 ││ 01 ││ 02 ││ 03 ││ ... │ │
│ └────┘└────┘└────┘└────┘└────┘└─────────┘ │
│ │ │ │ │ │ │ │
│ └─┬──┘ └──┬──┴────┘ │ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐ ┌─────────┐ │
│ │ /deep- ││ /deep- │ │ ... │ ◀── YOU ARE HERE │
│ │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, implement this plan"
Claude: *implements everything at once*
Result: Massive PR, unclear history, missed requirements discovered too late
You: "/deep-implement @planning/sections/."
deep-implement: Section 1 → TDD → Review → Commit → Section 2 → ...
Result: Atomic commits, code review at each step, clear progress tracking
Benefits:
Use deep-implement when:
/deep-planSkip deep-implement when:
Prerequisite: You need section files from
/deep-plan. If you don't have them, run/deep-plan @your-spec.mdfirst.
1. Point to your sections directory:
/deep-implement @planning/sections/.
2. Confirm target directory (where code will be written)
3. Follow the workflow for each section:
That's it. Each section gets implemented, reviewed, and committed before moving to the next.
Token Note: This workflow creates a detailed task list. Expand your terminal window to avoid UI flickering from the progress display.
┌─────────────────────────────────────────────────────────────────┐
│ deep-implement workflow │
├─────────────────────────────────────────────────────────────────┤
│ │
│ /deep-implement @planning/sections/. │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ Setup │ Validate inputs, detect git state, │
│ │ │ create task list │
│ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ For each section (in order): │ │
│ │ │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ TDD │ → │ Code │ → │ Interview │ │ │
│ │ │ Implement │ │ Review │ │ Fixes │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌────────────┐ ┌────────────┐ │ │
│ │ │ Stage │ │ Apply │ │ │
│ │ │ Changes │ │ Fixes │ │ │
│ │ └────────────┘ └────────────┘ │ │
│ │ │ │ │ │
│ │ └────────────┬───────────────────┘ │ │
│ │ ▼ │ │
│ │ ┌────────────┐ │ │
│ │ │ Commit │ Atomic commit per section │ │
│ │ └────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌────────────┐ │ │
│ │ │ Record │ Save state for resume │ │
│ │ └────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
/deep-planOption A: CLI commands
/plugin marketplace add piercelamb/deep-implement
/plugin install deep-implement
/plugin enable deep-implement
Option B: Via UI
/plugin marketplace add piercelamb/deep-implement
/plugin install deep-implement
/plugins
Then scroll to "Installed", find deep-implement, and click "Enable".
Already installed
/deep-planor/deep-project? All three plugins share a marketplace. If you've already added any one of the deep trilogy repos, just run/plugin install deep-implementdirectly — no need to add another marketplace.
Option A: Via settings.json
Clone the repo, then add to your project's .claude/settings.json:
git clone https://github.com/piercelamb/deep-implement.git /path/to/deep-implement
{
"plugins": {
"paths": ["/path/to/deep-implement"]
}
}
Option B: Via --plugin-dir flag (development/testing)
git clone https://github.com/piercelamb/deep-implement.git /path/to/deep-implement
claude --plugin-dir /path/to/deep-implement
/deep-implement @path/to/planning/sections/.
The sections directory must contain:
index.md with a SECTION_MANIFEST blocksection-NN-<name>.md files for each sectionIf the workflow is interrupted (context limit, user pause), simply re-run:
/deep-implement @planning/sections/.
The plugin detects completed sections via saved commit hashes and resumes from the next incomplete section.
The first time you run, you'll be asked where to write implementation code. This is saved in implementation/deep_implement_config.json and reused on resume.
For each section, the plugin runs:
| Step | What Happens |
|---|---|
| Read | Load section spec from section-NN-*.md |
| TDD Implement | Write tests first, then implementation (max 3 retry cycles) |
| Stage | git add new and modified files |
| Code Review | Subagent analyzes staged diff, writes review |
| Triage | Claude categorizes: ask user / auto-fix / let go |
| Interview | You decide on important items |
| Apply Fixes | Implement approved changes |
| Update Docs | Update section file with "What Was Built"—captures implementation decisions, code review changes, and deviations from plan |
| Commit | Atomic commit with conventional message |
| Record | Save commit hash for resume |
After every 2nd section, you're prompted to check context and optionally compact.
After running deep-implement, your implementation directory contains:
planning/
├── sections/
│ ├── index.md # Section manifest
│ └── section-NN-*.md # Updated with "What Was Built"
└── implementation/
├── deep_implement_config.json # Session state (for resume)
└── code_review/
├── section-01-diff.md # Staged diff
├── section-01-review.md # Code review findings
├── section-01-interview.md # Your decisions
└── ...
Your target directory contains the actual implementation code, with one commit per section.
Each section-NN-*.md file gets a "What Was Built" addendum after implementation. This captures:
This means anyone—human or AI agent—can quickly understand what was built without introspecting code. The section files become point-in-time documentation that stays accurate because they're updated at commit time.
/deep-planStart with clean working tree - Uncommitted changes can get mixed with section implementations.
Use a feature branch - The plugin warns if you're on main/master.
Expand your terminal - The task list can cause UI flickering in small windows.
Answer code review honestly - The interview is for real decisions, not rubber-stamping.
Trust the resume - If context fills up, re-run the same command. State is preserved.
Compact between sections - When prompted, consider compacting to free context space.
Issue: No @directory argument or invalid path
Solution:
/deep-implement @planning/sections/.index.md with SECTION_MANIFEST blockIssue: Git working tree is dirty
Solution:
Issue: You're on main/master/release branch
Solution:
git checkout -b feature/my-implementationIssue: Context limit hit during implementation
Solution:
/deep-implement @planning/sections/.Issue: Pre-commit hooks fail during commit
Solution:
pre_commit.detected_formatters in the preflight reportRun the test suite:
cd /path/to/deep-implement
uv run pytest tests/
deep_implement/
├── .claude-plugin/
│ ├── plugin.json # Plugin metadata
│ └── marketplace.json # Marketplace listing
├── LICENSE # MIT License
├── README.md # This file
├── pyproject.toml # Python project config
├── hooks/
│ └── hooks.json # SessionStart hook config
├── scripts/
│ ├── checks/ # Setup & validation scripts
│ ├── hooks/ # Hook implementations
│ ├── lib/ # Shared utilities
│ └── tools/ # Update state script
├── skills/
│ └── deep-implement/
│ ├── SKILL.md # Main skill definition
│ └── references/ # Protocol documents
├── agents/
│ └── code-reviewer/ # Code review subagent
└── tests/ # Test suite
Contributions welcome! Please:
uv run pytest tests/Pierce Lamb
0.2.1
.claude-plugin/
marketplace.json
plugin.json
.github/
CODEOWNERS
.gitignore
agents/
code-reviewer.md
assets/
hero.jpeg
CHANGELOG.md
hooks/
hooks.json
LICENSE
pyproject.toml
README.md
scripts/
__init__.py
checks/
__init__.py
setup_implementation_session.py
hooks/
__init__.py
capture-session-id.py
lib/
__init__.py
config.py
impl_tasks.py
sections.py
task_reconciliation.py
task_storage.py
tools/
__init__.py
update_section_state.py
skills/
deep-implement/
references/
apply-interview-fixes.md
code-review-interview.md
code-review-protocol.md
finalization.md
git-operations.md
implementation-loop.md
pre-commit-handling.md
section-doc-update.md
SKILL.md
tests/
__init__.py
conftest.py
hooks/
__init__.py
test_capture_session_id.py
test_config.py
test_integration.py
test_path_safety.py
test_pre_commit.py
test_sections.py
test_setup_implementation_session.py
test_task_storage.py
tools/
__init__.py
test_update_section_state.py© 2026 Flowy · Free and open source
Built for Claude Code · Not affiliated with Anthropic