agentic-dev-team

Agentic Dev Team

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.

Workflow

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. Checks for spec artifacts first — if none exist, asks whether to continue or run /specs. 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.

flowchart LR
    S["/specs\n4 artifacts"] -->|consistency gate| P["/plan\nTDD steps"]
    P -->|human approval| B["/build\nRED-GREEN-REFACTOR"]
    B -->|code review| PR["/pr\nquality gates"]

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.

Supporting commands

Command	When to use
/code-review	Run all review agents against changed files (also runs as part of /build)
/continue	Resume an in-progress build or plan across sessions
/browse	Visual QA via Playwright
/careful / /freeze / /guard	Safety modes for production-critical sessions

Automated pre-commit review

Every git commit is automatically gated by /code-review --changed. 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 --changed → if pass/warn, a .review-passed gate file is written → next commit attempt succeeds.

Bypass: git commit --no-verify skips the review gate.

How It Works

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.

Three-Phase Workflow (Orchestrator-Driven)

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 pre-checked by an automated plan reviewer 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. 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.

flowchart TD
    U([User Request]) --> O[Orchestrator]

    subgraph "Phase 1 — Research"
        O --> SP["/specs\nIntent · BDD · Architecture · Criteria"]
        SP --> DD["Design Doc\ndocs/specs/"]
    end

    DD --> HG1([Human Gate — approve spec + design])

    subgraph "Phase 2 — Plan"
        HG1 --> PL["/plan\nTDD steps · complexity tiers · acceptance criteria"]
        PL --> PR["Plan Reviewer\nprompts/plan-reviewer.md"]
    end

    PR --> HG2([Human Gate — approve plan])

    subgraph "Phase 3 — Implement (/build)"
        HG2 --> CV["Verify criteria testability\n(sprint contract gate)"]
        CV --> NEXT{"Next step?"}
        NEXT -->|more steps| IM["TDD Loop\nRED → GREEN → REFACTOR"]