AI Development Team

A reusable AI agent-team framework for your editor. 43 agent skills (a 15-agent core team + optional specialists + auto-loading language skills + cross-cutting process skills) plus a workflow-engine and an enforced, proportional workflow with approval gates — process, not prompts. Installs as a Claude Code plugin, or via the universal installer for Cursor, Kiro & VS Code. Open-source, no lock-in, free by default.

/po → /arch → /secops → [/fin] → [/legal] → [/ui] → /fe | /be → /rev → /qa + /e2e → /verify

The framework is a portable agent layer you install once and use across every project. It ships four things:

• Agent skills (claude/skills/) — lean SKILL.md personas that load deep references/ on demand; tech stacks (React/Angular/Vue, Java/Kotlin/Python/PHP, …) are references the role self-routes to, not separate agents. Core languages (Rust, Java, TypeScript; SQL with Postgres/MySQL/Oracle/SQLite branches) are the deliberate exception: knowledge skills in claude/skills/development/languages/ that auto-load from context whenever that language is written or reviewed — no persona, no command.

• The workflow-engine — a skill that classifies each change and refuses to skip a required gate.

• workflow.yaml — a versioned workflow definition, right-sized to the change via solo → small-team → regulated presets.

• Distribution — a Claude Code plugin (declare it once per project; the commit SHA is the version, so every push is an update), or install.sh, which wires the skills, commands and templates into whichever editor(s) you use.

• Process, not prompts. Gates are enforced by the engine, not left to a model's memory — and right-sized so a typo isn't treated like a feature.

• Roles, not micro-agents. Each agent is a role persona; technology stacks are references the role loads on demand.

• OSS-first, no lock-in. Zero paid accounts by default: file-based tickets + a markdown knowledge base. Jira/Confluence, MCP memory, and design tools are optional overlays.

vs. a single "do everything" agent

Relationship to Praxis

The agent skills in this repo are the shared agent layer — installed globally and used by every project, including its sibling Praxis (an open agent-memory runtime) and a separate governed knowledge backend, which live in their own separate repositories.

This framework stays focused on the durable, reusable layer: the agent skills, the workflow engine, the workflow definition, the templates, and the installer. Product-specific surfaces (dashboards, knowledge backends, memory runtimes) live in Praxis and a separate knowledge backend, not here. The earlier dashboard product that this repo once carried has been set aside — see ARCHIVE.md.

Team at a Glance

                              MANAGEMENT LAYER
           ┌─────────────────────┬─────────────────────┐
           │                     │                     │
    ┌──────▼──────┐      ┌───────▼───────┐     ┌──────▼──────┐
    │   PRODUCT   │      │    SCRUM      │     │  BUSINESS   │
    │    OWNER    │      │   MASTER      │     │  ANALYST    │
    │   /po /max  │      │  /sm /luda    │     │  /ba /anna  │
    └──────┬──────┘      └───────┬───────┘     └──────┬──────┘
           └─────────────────────┼─────────────────────┘
                                 │
                        ARCHITECTURE LAYER
           ┌─────────────────────┼─────────────────────┐
    ┌──────▼──────────┐                       ┌────────▼────────┐
    │    SOLUTION     │                       │    SECURITY     │
    │   ARCHITECT     │                       │    ENGINEER     │
    │  /arch /jorge   │                       │ /secops /soren  │
    └──────┬──────────┘                       └────────┬────────┘
           └─────────────────────┬─────────────────────┘
                                 │
                        DEVELOPMENT LAYER
         ┌───────────────────────┼───────────────────────┐
  ┌──────▼────────┐    ┌────────▼─────────┐    ┌────────▼────────┐
  │    BACKEND    │    │    FRONTEND      │    │     DEVOPS      │
  │   DEVELOPER   │    │   DEVELOPER      │    │    ENGINEER     │
  │  /be /james   │    │   /fe /finn      │    │                 │
  └──────┬────────┘    └────────┬─────────┘    └─────────────────┘
         │                      │
         │        QUALITY LAYER │
         ▼                      ▼
  ┌──────────────┐     ┌───────────────┐     ┌───────────────┐
  │     CODE     │     │  QA ENGINEER  │     │   E2E TESTER  │
  │   REVIEWER   │     │   /qa /rob    │     │  /e2e /adam   │
  │     /rev     │     └───────────────┘     └───────────────┘
  └──────────────┘

                        SPECIALIST LAYER
  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐
  │ UI/UX     │  │ACCOUNTANT │  │   LEGAL   │  │ MARKETING │
  │ /ui /aura │  │ /fin /inga│  │/legal/alex│  │ /mkt /apex│
  └───────────┘  └───────────┘  └───────────┘  └───────────┘

Quick Start

1. Install

Claude Code — as a plugin (recommended). Nothing to clone, and no ~/.claude setup: declare it per project and it reaches every session, including cloud sessions and anyone else who clones the repository.

// <your-project>/.claude/settings.json
{
  "extraKnownMarketplaces": {
    "aidevteam": {
      "source": { "source": "github", "repo": "olehsvyrydov/AI-development-team" }
    }
  },
  "enabledPlugins": { "ai-dev-team@aidevteam": true }
}

Trust the directory when prompted; the plugin installs on the next session. Verify with claude plugin details ai-dev-team, which lists the component inventory and its token cost.

Skills arrive namespaced — ai-dev-team:arch, ai-dev-team:rev — and the short aliases (/arch, /rev) keep working. The always-on contract ships as the ai-dev-team skill; a plugin cannot install a global CLAUDE.md, so that skill carries what a session needs to know about how work runs here.

To try it before declaring it: claude --plugin-dir ./claude from a clone of this repository.

Any editor — the installer. Still supported, and the only path for Cursor, Kiro and VS Code.

git clone https://github.com/olehsvyrydov/AI-development-team.git
cd AI-development-team
./install.sh                       # interactive: pick your editor(s)

The universal installer wires up whichever editors you choose and emits the right config for each — no lock-in:

./install.sh --editors=all --preset=solo --yes  # non-interactive (preset: solo|small-team|parallel-team|regulated)
./install.sh --editors=claude --scope=user    # global ~/.claude (Claude Code)
./install.sh --dry-run                        # preview, change nothing
./install.sh --link                           # symlink content (dev mode)
./install.sh --uninstall                      # remove what it installed

Optional advanced Claude backends (Atlassian, memory MCP, hooks): scripts/setup-claude-backends.sh.

2. Verify

# In Claude Code:
/agents         # List the team (15 core + specialists)
/po             # Start with Product Owner
/arch           # Get architecture review

What Gets Installed

As a plugin, nothing is copied into your project. The repository is the plugin:

AI-development-team/
├── .claude-plugin/
│   └── marketplace.json         # the catalogue — points at ./claude
└── claude/                      # ← the plugin root
    ├── .claude-plugin/
    │   └── plugin.json          # the manifest. `version` is deliberately omitted,
    │                            #   so the commit SHA is the version and every push
    │                            #   is an update
    ├── skills/                  # loaded as ai-dev-team:<name>, short aliases intact
    ├── commands/
    ├── templates/
    └── workflow/

CLAUDE.md and AGENTS.md at the plugin root are readable mirrors — a plugin cannot load either, so the always-on contract ships as the ai-dev-team skill instead.

Via install.sh, content is copied (or symlinked with --link) into the target scope. Only skills/, commands/, templates/ and workflow/ are deployed; the instructions file is generated at the destination:

~/.claude/
├── CLAUDE.md                    # generated pointer (TDD workflow, approval gates)
├── TEAM_WORKFLOW.md             # Complete team process documentation
│
├── skills/                      # 43 agent skill files (15 core + specialists + language + process skills)
│   ├── management/              # Product Owner, Scrum Master, Business Analyst
│   ├── architecture/            # Solution Architect, GraphQL Developer
│   ├── development/
│   │   ├── backend/             # Java/Spring, Kotlin, PHP/Laravel, Python/FastAPI
│   │   ├── frontend/            # React/Next.js, Angular, Vue, Flutter
│   │   ├── languages/           # Rust, Java, TypeScript, SQL (auto-loading knowledge skills, no persona)
│   │   └── mobile/              # Native iOS/Android
│   ├── quality/
│   │   ├── review/              # Full-stack, Backend, Frontend, PHP reviewers
│   │   ├── testing/             # QA, E2E (Playwright/Detox), BDD/Cucumber, unit testers
│   │   └── verify/              # Completion auditor (gate)
│   ├── operations/              # DevOps, SecOps, MLOps, SRE, Terraform
│   ├── design/                  # UI/UX Designer, UX Research, JavaFX Designer
│   ├── compliance/              # Accountant, Legal (generic + UK regional variants)
│   ├── marketing/               # Product Marketing Strategist
│   ├── specialized/             # Technical Writer, Kai (self-improving meta-agent)
│   │
│   ├── ai-dev-team/             # ─┐ cross-cutting process skills — judgement, not a role.
│   ├── workflow-engine/         #  │ They sit at the top level because they apply across
│   ├── fid-lifecycle/           #  │ every role: the gate contract, the always-on framework
│   ├── verify-landed/           #  │ contract, work-item lifecycle, proving a change landed,
│   ├── review-tier/             #  │ how much review to buy, which model tier to spend,
│   ├── model-selection/         #  │ how to investigate, how to audit a grounded answer,
│   ├── research-method/         #  │ and how to run a PR to a mergeable state.
│   ├── answer-audit/            #  │
│   ├── parallel-delivery/       #  │ claiming, isolating and reporting back a ticket
│   └── pull-request/            # ─┘ worked by a separate session.
│
├── commands/                    # 50 slash commands
│   ├── [role-based]             # /po, /sm, /ba, /arch, /fe, /be, /rev, /qa, /e2e ...
│   ├── [persona aliases]        # /max, /luda, /jorge, /finn, /james, /adam ...
│   └── [utility]                # /agents, /bug, /issue, /memory, /all, /kai ...
│
├── templates/                   # 6 document templates
│   ├── adr-template.md          # Architecture Decision Records
│   ├── user-story-template.md   # User stories with Given/When/Then AC
│   ├── sprint-template.md       # Sprint planning & tracking
│   ├── code-review-template.md  # Structured code review reports
│   ├── investigation-report-template.md
│   └── retrospective-template.md
│
└── workflow/                    # workflow.yaml + schema + optional MCP adapters

Agent Reference

Core Agents

Both naming conventions work: /arch (role-based, primary) and /jorge (persona alias) invoke the same agent.

On-Demand Specialists

These aren't part of the core 15 — they load on demand when their discipline is in play (invoke directly, or a core agent routes to them).

Two special-purpose agents are documented in their own sections: /kai (self-improving meta-agent) and /verify (completion auditor / workflow gate).

Process Skills

Role agents cover who does the work. These cover how it is decided, checked and paid for. They live at the top level of claude/skills/ and self-trigger from their descriptions — you rarely invoke them by name, but knowing they exist lets you reach for one deliberately.

The rule they exist to enforce: a ticket is Done only when its negative criteria are met — the guard, the refusal, the "cannot bypass" — and each names the symbol that enforces it. Happy paths ship; the things that stop bad outcomes do not, unless someone checks.

Technology Extensions

These activate alongside core agents when working with specific technologies:

Workflow

Development Sequence

Every feature follows this pipeline:

1. /po + /ba    → Define vision, write user stories with behavioral AC
2. /arch        → Architecture review and ADR (when triggered)
3. /secops      → Security review (safety override — never skipped for size)
4. [/fin]       → Finance review (if payments, billing, tax)
5. [/legal]     → Legal review (if GDPR, privacy, contracts)
6. [/ui]        → UI design (if frontend feature)
7. /fe or /be   → TDD implementation (tests first, then code)
8. /rev         → Code review (quality + security + requirements)
9. /qa + /e2e   → Test case design + automated E2E tests

Approval Gates

Gates are proportional — the workflow-engine decides which apply per change-class / trigger / preset (a typo isn't a feature). Security gates are a safety override: triggered by risk, never skipped for being "small".

TDD (Mandatory)

All development follows strict Test-Driven Development:

1. Red — Write failing tests that define expected behavior
2. Green — Write minimum code to pass tests
3. Refactor — Clean up while keeping tests green
4. Commit — Git commit after successful test run

Bug Workflow

/bug Login button doesn't work on mobile Safari

Creates a structured investigation → reproduction test → TDD fix → code review → E2E test.

Jira & Confluence (optional overlay)

By default the team is file-based — Backlog.md tickets + a markdown knowledge base, zero paid accounts. Jira/Confluence are an optional overlay: enable them in workflow.yaml and connect the Atlassian MCP server:

claude mcp add --scope user --transport http atlassian https://mcp.atlassian.com/v1/mcp

• Jira: Kanban board for issue tracking, ticket lifecycle, sprint management
• Confluence: Architecture decisions, security reviews, investigation reports, sprint documentation
• Git conventions: Branch names (feature/PROJ-123-description), commit messages (PROJ-123: Implement feature)

Optional Add-Ons

Multi-LLM Consultation (/all)

Query multiple frontier models from within Claude Code and get consensus, divergent views, and synthesized recommendations.

/all Should we use event sourcing for our payment system?
/all Review this architecture for scalability issues

Routes through OpenRouter (single API key for all models) with direct OpenAI fallback.

cd multi-llm/mcp
python3 -m venv .venv && .venv/bin/pip install -e .

claude mcp add --scope user multi-llm \
  -e OPENROUTER_API_KEY=<your-key> \
  -- /path/to/multi-llm/mcp/.venv/bin/python3 -m consult_mcp

See: Multi-LLM Guide

Self-Improving Meta-Agent (/kai)

Kai promotes working-rules you have already approved into permanent SKILL.md updates. It emits a diff and stops — it never applies, stages, or commits a change.

Its input is working-rules you have already approved — from whatever the project uses: an agent-memory MCP server, a file the team maintains, or nothing at all. Kai names no product and depends on none; concrete backends are optional adapters documented in claude/skills/specialized/kai/references/rule-sources.md. Kai reads only the approved rules, drops any that are project-specific, duplicated or too vague, and proposes the rest.

/kai                       # review all approved rules, propose what qualifies
/kai --skill <path>        # restrict to rules routing to one skill
/kai --audience reviewer   # restrict by audience (reviewer|developer|tester|all)

Pipeline: session → rules mined automatically → you approve → Kai filters for universality → diff for review → you apply it, or you do not.

With no backend connected, /kai reports that there are no approved rules and stops. It does not invent them.

Extending the Framework

Adding a New Agent

1. Create a skill directory under the appropriate category:

   claude/skills/development/backend/go/go-developer/SKILL.md
   

2. Follow the SKILL.md format (YAML frontmatter + structured Markdown sections):

   ---
   name: go-developer
   description: "Senior Go Developer with 8+ years systems programming experience"
   ---
   
   # Go Developer
   
   ## Trigger
   Use when working with Go code, services, or CLI tooling.
   
   ## Context
   You are a Senior Go Developer...
   
   ## Expertise
   ### Modern Go
   - Goroutines, channels, context propagation
   ...
   
   ## Anti-Patterns
   - Never discard a returned error
   ...
   

3. Create a slash command in claude/commands/go.md

4. Re-install / update: ./install.sh (idempotent)

For a core language rather than a role, use the knowledge-skill pattern instead — see claude/skills/development/languages/ (Rust, SQL): no persona, no command; the frontmatter description auto-triggers from context and the role agents route into it. The recipe is in CONTRIBUTING.md under "Add a language skill".

See: Skill Extension Guide

Adding a New Technology to an Existing Agent

Edit the relevant SKILL.md and add a new subsection under ## Expertise. Skills should contain universal, reusable knowledge — no project-specific references, ticket IDs, or sprint numbers.

Requirements

The core framework (15-agent core team + optional specialists) works with just Claude Code — no additional dependencies.

Documentation

Version History

See CHANGELOG.md for full details.

Contributing

1. Fork the repository
2. Create a feature branch
3. Install in dev mode: ./install.sh --link
4. Make changes to skills in claude/skills/
5. Submit a pull request

See Skill Extension Guide for detailed contribution guidelines.

License

MIT License — See LICENSE file for details.