Plugins
This directory contains comprehensive documentation for all 13 plugins in the Context Engineering Kit. Each plugin is designed to enhance Claude Code with specific capabilities focused on code quality, development workflows, and continuous improvement.
Quick Navigation
Reflexion - Self-refinement and iterative improvement
Code Review - Multi-agent code quality analysis
Git - Streamlined Git operations
Test-Driven Development - TDD methodology and best practices
Subagent-Driven Development - Task delegation with quality gates
Domain-Driven Development - Code quality and architecture patterns
Spec-Driven Development - Spec-Driven workflow
First Principles Framework - Structured reasoning with ADI cycle
Kaizen - Continuous improvement and root cause analysis
Customaize Agent - Create and refine Claude Code extensions
Docs - Documentation management
Tech Stack - Language and framework best practices
MCP - Model Context Protocol integration
Installation
All plugins follow the same installation pattern:
See individual plugin documentation for specific installation commands and verification steps.
Overview by Category
Quality & Refinement
Reflexion
Self-refinement framework that introduces feedback and refinement loops to improve output quality.
Key Features:
Reflect on previous responses
Multi-perspective critique with debate
Memory updates with insights
When to use: After completing any task to verify quality and identify improvements.
Code Review
Comprehensive code review using multiple specialized agents for thorough quality evaluation.
Key Features:
Multi-agent review (bug hunter, security auditor, test coverage reviewer, etc.)
Local changes review
Pull request review
When to use: Before committing changes or creating pull requests.
Development Workflows
Test-Driven Development
TDD methodology with anti-pattern detection and testing best practices.
Key Features:
TDD workflow guidance
Common anti-patterns awareness
Testing subagent skills
When to use: When implementing new features with test-first approach.
Subagent-Driven Development
Execution framework for parallel/sequential task dispatch, competitive generation, and multi-agent evaluation with quality gates.
Key Features:
Execution patterns: parallel (
do-in-parallel), sequential (do-in-steps), competitive (do-competitively), exploration (tree-of-thoughts)Evaluation: single judge (
judge) or multi-judge debate (judge-with-debate)Fresh context isolation per task
Quality gates with code review between tasks
Multi-agent architecture patterns (supervisor, peer-to-peer, hierarchical)
When to use: For complex features requiring multiple independent tasks, competitive solution generation, or when single-agent context limits are exceeded.
Spec-Driven Development
Comprehensive Spec-Driven Development workflow using specialized agents for each phase.
Key Features:
Complete workflow: setup → specify → plan → tasks → implement → document
Multiple specialized agents (architect, explorer, reviewer, etc.)
Constitution-based development
When to use: For complex features requiring detailed specifications and planning.
First Principles Framework
Structured reasoning methodology implementing the ADI (Abduction-Deduction-Induction) cycle for auditable decision-making. The FPF plugin implements structured reasoning using the First Principles Framework methodology developed by Anatoly Levenchuk a methodology for rigorous, auditable reasoning. The killer feature is turning the black box of AI reasoning into a transparent, evidence-backed audit trail.
Key Features:
Hypothesis generation with competing alternatives
Logical verification and constraint checking
Empirical validation with evidence tracking
Trust calculus with Weakest Link principle
Design Rationale Records (DRRs)
Evidence freshness management
The core cycle follows three modes of inference:
Abduction — Generate competing hypotheses (don't anchor on the first idea).
Deduction — Verify logic and constraints (does the idea make sense?).
Induction — Gather evidence through tests or research (does the idea work in reality?).
When to use: For architectural decisions with long-term consequences requiring auditable reasoning trails.
Code Quality & Architecture
Domain-Driven Development
Code quality and architecture patterns including Clean Architecture and SOLID principles.
Key Features:
Code formatting setup
Architecture patterns
Design principles
When to use: Setting up new projects or enforcing code quality standards.
Process & Analysis
Git
Streamlined Git operations with conventional commits, pull request management, and advanced workflow patterns.
Key Features:
Conventional commits with emoji
Pull request creation
Issue analysis and loading
Git worktrees for parallel branch development
Git notes for commit metadata annotations
When to use: For all Git operations to maintain commit and PR quality, or when working on multiple branches simultaneously.
Kaizen
Continuous improvement methodology with multiple root cause analysis techniques.
Key Features:
Auto-selected analysis methods
Five Whys analysis
A3 problem solving
PDCA cycle
When to use: Investigating issues, bugs, or process improvements.
Customization & Setup
Customaize Agent
Tools for creating and refining Claude Code commands, skills, and hooks.
Key Features:
Command creation assistant
Skill development guide
Prompt testing framework
Anthropic best practices
Context engineering fundamentals (attention budget, progressive disclosure)
Agent evaluation frameworks (LLM-as-Judge, rubrics, bias mitigation)
When to use: Creating custom plugins, extending Claude Code, or optimizing agent performance.
Docs
Project analysis and documentation management commands.
Key Features:
Documentation updates
Implementation tracking
When to use: After completing development phases to update documentation.
Tech Stack
Language and framework-specific best practices setup.
Key Features:
TypeScript best practices
Framework-specific guidelines
When to use: Setting up new projects or enforcing language-specific standards.
MCP
Model Context Protocol server integration and setup.
Key Features:
Context7 MCP setup
Serena MCP setup
MCP server development guide
When to use: Integrating external services with Claude Code.
Last updated