A Claude Code plugin that adds a full persona-driven AI development team to any project. The Orchestrator routes tasks to specialized agents, inline review checkpoints catch quality issues during implementation, and skills provide reusable knowledge modules that any agent can draw on.
Four commands drive feature development from idea to pull request:
/specs → /plan → /build → /pr
| Step | Command | What it does |
|---|---|---|
| 1. Specify | /specs |
Collaborate on four artifacts: Intent, BDD/Gherkin scenarios, Architecture notes, Acceptance Criteria. A consistency gate must pass before moving on. Skip for bug fixes, refactors, or trivial changes. |
| 2. Plan | /plan |
Create a step-by-step TDD implementation plan. Four plan review personas (Acceptance Test, Design, UX, Strategic critics) challenge the plan before the human sees it. Human approves before any code is written. |
| 3. Build | /build |
Execute the approved plan. Each step follows RED-GREEN-REFACTOR with inline review checkpoints (spec-compliance first, then quality agents). Produces verification evidence. |
| 4. Ship | /pr |
Run quality gates (tests, typecheck, lint, code review) and create a pull request. |
Each step produces artifacts the next step consumes. Human review gates sit between each transition.
For bug fixes or simple tasks, skip /specs and start at /plan or go straight to implementation. The orchestrator routes trivially when the full workflow isn't needed.
| Command | When to use |
|---|---|
/code-review |
Run all review agents, auto-fix actionable issues, and re-run until clean (up to 5 iterations) |
/continue |
Resume an in-progress build or plan across sessions |
/browse |
Visual QA via Playwright |
/benchmark |
Runtime performance metrics (Core Web Vitals, resource sizes) against baselines |
/careful / /freeze / /guard |
Safety modes for production-critical sessions |
Every git commit is automatically gated by /code-review. A PreToolUse hook detects commit attempts and blocks them until a passing review exists for the exact set of staged files.
Flow: attempt commit → hook blocks → Claude runs /code-review (auto-scopes to uncommitted changes) → if pass/warn, a .review-passed gate file is written → next commit attempt succeeds.
Bypass: git commit --no-verify skips the review gate.
Team agents define roles (persona, behavior, collaboration). Review agents check work quality in real time. Skills define knowledge (patterns, guidelines, procedures). Slash commands invoke agents and skills directly. The Orchestrator controls task routing, model selection, and the inline review feedback loop.
For complex tasks where the orchestrator manages the full lifecycle, every non-trivial task follows Research → Plan → Implement with human review gates between phases:
- Research produces a design document (
docs/specs/) with problem statement, alternatives, and scope boundaries - Plan is critically reviewed by four plan review personas (Acceptance Test, Design & Architecture, UX, and Strategic critics) running in parallel before the human sees it
- Implement enforces strict TDD (RED-GREEN-REFACTOR with hard gates), uses worktree isolation for parallel units, and runs a three-stage inline review: spec-compliance first ("does code match spec?"), then quality agents ("is code good?"), then browser verification for UI changes. Actionable issues (error/warning severity with high/medium confidence) are auto-fixed and re-reviewed in a loop (up to 5 iterations) — only issues requiring human judgment are escalated. All agents must provide verification evidence (fresh test output) before claiming completion. After the human gate, a branch workflow handles PR creation and merge strategy.
Required:
- Claude Code installed and authenticated
jq— used by hooks for JSON parsing- macOS:
brew install jq - Linux:
apt install jqoryum install jq
- macOS:
gh— GitHub CLI, used by/prand/triagefor creating PRs and issues- macOS:
brew install gh - Linux: see GitHub CLI install docs
- Then authenticate:
gh auth login
- macOS:
Optional — by feature:
| Tool(s) | Required for | Install |
|---|---|---|
semgrep |
/semgrep-analyze, static analysis pre-pass in /code-review |
See below |
playwright |
/browse (browser-based QA) |
See below |
hadolint, trivy, grype |
/docker-image-audit |
See below |
Optional — auto-formatting (detected per language):
The post-format hook auto-formats files on every edit. It detects available formatters and degrades silently if none are installed. Install the ones relevant to your stack:
| Tool | Language | Install |
|---|---|---|
prettier |
JS/TS/CSS/HTML/JSON | npm install -D prettier (project-local) |
eslint |
JS/TS | npm install -D eslint (project-local) |
ruff |
Python | pip install ruff or brew install ruff |
black |
Python (fallback if ruff absent) | pip install black |
gofmt |
Go | Included with Go toolchain |
rustfmt |
Rust | rustup component add rustfmt |
rubocop |
Ruby | gem install rubocop (or add to Gemfile) |
google-java-format |
Java | brew install google-java-format or GitHub releases |
ktlint |
Kotlin | brew install ktlint or GitHub releases |
dotnet format |
C# | Included with .NET SDK 6+ |
Optional — quality gates in /pr (detected per stack):
/pr auto-detects test runners, type checkers, and linters based on project manifests. No configuration needed — if the tool is installed and the project has the relevant config file, it runs automatically.
| Tool | Detected via | Install |
|---|---|---|
tsc |
tsconfig.json |
npm install -D typescript (project-local) |
mypy |
mypy.ini or pyproject.toml [mypy] |
pip install mypy |
pylint |
which pylint |
pip install pylint |
golangci-lint |
which golangci-lint |
brew install golangci-lint or install docs |
pip install semgrep
# or: brew install semgrep
# or: pipx install semgrepnpx playwright install chromiumRequires Node.js. Used by /browse for browser-based visual QA.
# macOS (Homebrew)
brew install hadolint trivy grype
# Linux
# hadolint
curl -sL -o /usr/local/bin/hadolint \
"https://github.com/hadolint/hadolint/releases/latest/download/hadolint-Linux-x86_64"
chmod +x /usr/local/bin/hadolint
# trivy
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin
# grype
curl -sSfL https://raw.githubusercontent.com/anchore/grype/main/install.sh | sh -s -- -b /usr/local/binAll three also run as Docker containers if you prefer not to install locally — see the docker-image-audit skill docs for details.
Add the marketplace source, then install the plugin. The marketplace resolves the plugin location automatically from marketplace.json.
From GitHub:
claude plugin marketplace add https://github.com/bdfinst/agentic-dev-team
claude plugin install agentic-dev-team@bfinsterFrom a local clone:
claude plugin marketplace add /path/to/agentic-dev-team
claude plugin install agentic-dev-team@bfinsterBy default the marketplace is registered at user scope (available in all projects). To scope it to a single project:
claude plugin marketplace add --scope project https://github.com/bdfinst/agentic-dev-team
claude plugin install --scope project agentic-dev-team@bfinsterIf you previously installed the plugin before the directory restructure (pre-v2.1), remove and re-add the marketplace source:
claude plugin marketplace remove agentic-dev-team
claude plugin marketplace add https://github.com/bdfinst/agentic-dev-team
claude plugin install agentic-dev-team@bfinsterAfter starting Claude Code, confirm the system is working:
> What agents are available on this team?
The plugin ships with 12 team agents, 19 review agents, 31 skills, 8 subagent prompt templates, and 56 slash commands. For the full catalogs:
- Agents — team agent roster, review agent roster, persona template, how to add/remove/customize
- Skills & Commands — skills catalog (by category), slash commands catalog, how to add new ones
.claude-plugin/marketplace.json # Marketplace catalog
plugins/agentic-dev-team/ # Plugin source (ships to users)
├── .claude-plugin/plugin.json # Plugin manifest + version
├── agents/ # Team agents (12) + review agents (19)
├── commands/ # Slash commands
├── skills/ # Reusable knowledge modules (31 skills)
├── hooks/ # PreToolUse guards + PostToolUse advisory hooks
├── knowledge/ # Progressive disclosure reference files
├── templates/ # Language-specific agent templates
├── settings.json # Hook registrations
├── install.sh # Prerequisite check
└── CLAUDE.md # Orchestration pipeline config (auto-loaded)
docs/ # Dev documentation (not shipped)
plans/ # Implementation plans (not shipped)
evals/ # Agent eval fixtures (not shipped)
reports/ # Review reports (not shipped)
Install the plugin from the local path into a test project:
claude plugin install --scope project /path/to/agentic-dev-team/plugins/agentic-dev-teamEval suite — run against a single agent or the full set:
/agent-eval
/agent-eval plugins/agentic-dev-team/agents/naming-review.md
Structural compliance — verify all agents and commands:
/agent-audit
Hooks are registered in plugins/agentic-dev-team/settings.json and ship with the plugin. When developing locally, hooks run from plugins/agentic-dev-team/hooks/.
/agent-add <description or URL to a coding standard>
This scaffolds the agent file, adds it to the registry in CLAUDE.md, and creates eval fixtures. Run /agent-audit and /agent-eval to verify compliance.
| Guide | Description |
|---|---|
| Getting Started | Hands-on tutorial: invoke agents, skills, and common workflows |
| Architecture | Context management, quality assurance, governance, multi-LLM routing |
| Agents | Agent roster, persona template, adding/removing/customizing agents |
| Skills & Commands | Skills catalog, slash commands catalog |
| Eval System | How review agent accuracy is measured and graded |