piercelamb/deep-implement

Dernière activité source enregistrée: 28 février 2026 à 14:47

Catalogue SkillsMP mis à jour: 2 novembre 2026 à 18:02

skills collectés: 1

Étoiles GitHub: 55
Forks GitHub: 14

Installer avec un assistant IA

Copiez ce prompt dans l’assistant IA que vous utilisez.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/piercelamb/deep-implement.

README du dépôt

Fichier source du README : README.md

Lire le README source

Afficher le README complet

![deep-implement hero](assets/hero.jpeg) # /deep-implement, a Claude Code plugin ![Version](https://img.shields.io/badge/version-0.2.1-blue) ![Status](https://img.shields.io/badge/status-beta-orange) ![License](https://img.shields.io/badge/license-MIT-green) ![Claude Code](https://img.shields.io/badge/Claude%20Code-Plugin-purple) ![Python](https://img.shields.io/badge/python-3.11%2B-blue) > **Blog posts:** > - [The Deep Trilogy](https://pierce-lamb.medium.com/the-deep-trilogy-claude-code-plugins-for-writing-good-software-fast-33b76f2a022d) - How the three plugins work together > - [What I Learned](https://pierce-lamb.medium.com/what-i-learned-while-building-a-trilogy-of-claude-code-plugins-72121823172b) - 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`](https://github.com/piercelamb/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`](https://github.com/piercelamb/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. ## TL;DR ``` /plugin marketplace add piercelamb/deep-implement /plugin install deep-implement /plugin enable deep-implement /deep-implement @planning/sections/. ``` ## Table of Contents - [Overview](#overview) - [The Deep Trilogy](#the-deep-trilogy) - [Why deep-implement?](#why-deep-implement) - [When to Use](#when-to-use) - [Quick Start](#quick-start) - [How It Works](#how-it-works) - [Installation](#installation) - [Usage](#usage) - [Workflow Steps](#workflow-steps) - [Output Files](#output-files) - [Requirements](#requirements) - [Best Practices](#best-practices) - [Troubleshooting](#troubleshooting) - [Testing](#testing) - [Project Structure](#project-structure) - [Contributing](#contributing) ## Overview **deep-implement** orchestrates a disciplined implementation workflow: ``` Read Section → TDD Implementation → Code Review → Interview → Commit → Next ``` For each section from `/deep-plan`, the plugin: - **Implements with TDD**: Write tests first, then implementation - **Runs Code Review**: A dedicated subagent reviews staged changes - **Interviews You**: Triage findings, get your input on real decisions - **Updates Section Docs**: Records what was actually built back into the section file - **Commits Atomically**: One commit per section with review trail - **Tracks Progress**: Resume from any point after interruption 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. ## The Deep Trilogy 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`](https://github.com/piercelamb/deep-project) | Decompose | Vague requirements | Focused spec files | | [`/deep-plan`](https://github.com/piercelamb/deep-plan) | Plan | Spec file | Section files with TDD | | [`/deep-implement`](https://github.com/piercelamb/deep-implement) | Build | Section files | Production code | **Where to start?** - **Vague multi-component project?** Start with [`/deep-project`](https://github.com/piercelamb/deep-project) - **Single focused feature?** Start with [`/deep-plan`](https://github.com/piercelamb/deep-plan) - **Already have section files?** Start here with `/deep-implement` ## Why deep-implement? ### Without deep-implement ``` You: "Claude, implement this plan" Claude: *implements everything at once* Result: Massive PR, unclear history, missed requirements discovered too late ``` ### With deep-implement ``` 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:** - **Incremental verification**: Each section is tested and reviewed before moving on - **Clean git history**: One commit per section, not one massive commit - **Human oversight**: You approve code review fixes, not rubber-stamp everything - **Living documentation**: Section files are updated with what was actually built—a human or AI can get up to speed instantly without reading code - **Resumable**: Context limit? Restart exactly where you left off ## When to Use **Use deep-implement when:** - You have section files from `/deep-plan` - You want TDD methodology enforced - You want code review between implementation steps - You care about clean git history - The implementation is complex enough to benefit from structured workflow **Skip deep-implement when:** - Simple one-file changes - Sections are trivial and review overhead isn't worth it - You want to implement multiple sections in parallel (deep-implement is sequential) ## Quick Start > **Prerequisite**: You need section files from `/deep-plan`. If you don't have them, run `/deep-plan @your-spec.md` first. **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: - Implementation with TDD - Code review (you'll be interviewed on findings) - Commit 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. ## How It Works ``` ┌─────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ │ └────────────┘ │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ``` ## Installation ### Prerequisites - [Claude Code](https://claude.ai/code) installed - [uv](https://docs.astral.sh/uv/) (Python package manager) - Python 3.11+ - A git repository (recommended) - Section files from `/deep-plan` ### Install via Marketplace (Recommended) **Option 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-plan` or `/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-implement` directly — no need to add another marketplace. ### Manual Installation **Option A: Via settings.json** Clone the repo, then add to your project's `.claude/settings.json`: ```bash git clone https://github.com/piercelamb/deep-implement.git /path/to/deep-implement ``` ```json { "plugins": { "paths": ["/path/to/deep-implement"] } } ``` **Option B: Via --plugin-dir flag (development/testing)** ```bash git clone https://github.com/piercelamb/deep-implement.git /path/to/deep-implement claude --plugin-dir /path/to/deep-implement ``` ## Usage ### Basic Invocation ``` /deep-implement @path/to/planning/sections/. ``` The sections directory must contain: - `index.md` with a `SECTION_MANIFEST` block - `section-NN-<name>.md` files for each section ### Resuming If 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. ### Target Directory 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. ## Workflow Steps 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. ## Output Files 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. ### Living Documentation Each `section-NN-*.md` file gets a "What Was Built" addendum after implementation. This captures: - Actual files created/modified - Implementation decisions made during coding - Changes from code review - Deviations from the original plan 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. ## Requirements - Claude Code - Python >= 3.11 - uv package manager - Git repository (recommended) - Section files from `/deep-plan` ## Best Practices 1. **Start with clean working tree** - Uncommitted changes can get mixed with section implementations. 2. **Use a feature branch** - The plugin warns if you're on main/master. 3. **Expand your terminal** - The task list can cause UI flickering in small windows. 4. **Answer code review honestly** - The interview is for real decisions, not rubber-stamping. 5. **Trust the resume** - If context fills up, re-run the same command. State is preserved. 6. **Compact between sections** - When prompted, consider compacting to free context space. ## Troubleshooting ### "Sections directory required" **Issue**: No @directory argument or invalid path **Solution**: - Provide path to sections directory: `/deep-implement @planning/sections/.` - Ensure the directory contains `index.md` with SECTION_MANIFEST block ### "Working tree has uncommitted changes" **Issue**: Git working tree is dirty **Solution**: - Commit or stash changes before running - Or choose "Continue anyway" if you understand the risk ### "Protected branch detected" **Issue**: You're on main/master/release branch **Solution**: - Create a feature branch first: `git checkout -b feature/my-implementation` - Or choose "Continue" if you really want to commit to this branch ### Workflow interrupted mid-section **Issue**: Context limit hit during implementation **Solution**: - Re-run `/deep-implement @planning/sections/.` - The plugin detects completed sections and resumes from the next one - If interrupted mid-section, it will restart that section ### Pre-commit hook failures **Issue**: Pre-commit hooks fail during commit **Solution**: - The plugin automatically retries after fixing common issues - Check `pre_commit.detected_formatters` in the preflight report - Manually fix issues if retries fail ## Testing Run the test suite: ```bash cd /path/to/deep-implement uv run pytest tests/ ``` ## Project Structure ``` 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 ``` ## Contributing Contributions welcome! Please: 1. Clone the repository 2. Create a feature branch 3. Run tests: `uv run pytest tests/` 4. Submit a pull request ## License [MIT](./LICENSE) ## Author Pierce Lamb ## Version 0.2.1

Chargement du README du dépôt…

Skills dans ce dépôt

Développeurs de logiciels

1 catégories métier · 100% classifié

skill

métier

description

mis à jour

deep-implement

Développeurs de logiciels

Implements code from /deep-plan section files with TDD methodology, code review, and git workflow. Use when implementing plans created by /deep-plan.

Langue du texte source : anglais

2026-02-28

Affichage de 1 skills collectés sur 1.