AI Development Team

A complete virtual software development team for Claude Code. 40 specialized AI agents — from Product Owner to E2E Tester — that collaborate through a structured workflow with approval gates, TDD, and semantic knowledge retrieval.

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

Each agent is a Claude Code skill with deep domain expertise, specific technology knowledge, and awareness of its role in the team workflow. Agents hand off work to each other, write to Jira/Confluence, and accumulate institutional knowledge through a RAG-powered memory system.

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

git clone https://github.com/olehsvyrydov/AI-development-team.git
cd AI-development-team
./install.sh

The installer detects existing ~/.claude configuration and offers:

• Merge — add new skills, keep your existing ones (recommended)
• Replace — backup existing ~/.claude and install fresh
• Link — symlink for development (changes in repo reflect immediately)

Or use flags directly: ./install.sh --merge, ./install.sh --replace, ./install.sh --link

2. Verify

# In Claude Code:
/agents         # List all 40 agents
/po             # Start with Product Owner
/arch           # Get architecture review

3. Optional: Enable RAG Knowledge Base

The installer will offer to set up the semantic knowledge base (requires Docker + Python 3.11+). You can also do it manually later — see RAG Setup.

What Gets Installed

~/.claude/
├── CLAUDE.md                    # Global instructions (TDD workflow, approval gates)
├── TEAM_WORKFLOW.md             # Complete team process documentation
│
├── skills/                      # 40 agent skill files
│   ├── 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
│   │   └── desktop/             # JavaFX
│   ├── quality/
│   │   ├── review/              # Full-stack, Backend, Frontend, PHP reviewers
│   │   └── testing/             # QA, E2E (Playwright/Detox), BDD/Cucumber, unit testers
│   ├── operations/              # DevOps, SecOps, MLOps, Terraform, HMRC API
│   ├── design/                  # UI/UX Designer, JavaFX Designer
│   ├── compliance/              # Accountant, Legal (generic + UK regional variants)
│   ├── marketing/               # Product Marketing Strategist
│   └── specialized/             # Technical Writer, Kai (self-improving meta-agent)
│
├── commands/                    # 37 slash commands
│   ├── [14 role-based]          # /po, /sm, /ba, /arch, /fe, /be, /rev, /qa, /e2e ...
│   ├── [13 persona aliases]     # /max, /luda, /jorge, /finn, /james, /adam ...
│   └── [10 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

Agent Reference

Core Agents

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

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 (MANDATORY for all features)
3. /secops      → Security review (MANDATORY for all features)
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

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 Integration

The framework integrates with Atlassian tools via 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/LJ-123-description), commit messages (LJ-123: Implement feature)

AI Platform Features

Beyond agent skills, the framework includes an intelligent knowledge platform with three systems:

RAG Knowledge Base (AI Team Memory)

Semantic search across agent expertise, architecture decisions, sprint learnings, and code patterns — powered by Qdrant + Voyage AI.

# In Claude Code:
/memory What does Jorge know about CQRS?
/memory Search for React testing patterns

4 MCP tools provided:

• memory_search — semantic search across any collection
• memory_store — persist new learnings at runtime
• memory_agent_expertise — ask "What does [agent] know about X?"
• memory_stats — collection health and counts

5 Qdrant collections:

Setup:

# 1. Start Qdrant
cd claude/rag && docker compose up -d

# 2. Install Python dependencies
cd mcp-server && python3 -m venv .venv && .venv/bin/pip install -e .

# 3. Initialize collections
cd .. && mcp-server/.venv/bin/python3 -m management.stats

# 4. Ingest skills into Qdrant
VOYAGE_API_KEY=<key> mcp-server/.venv/bin/python3 -m ingestion.ingest ~/.claude/skills/

# 5. Register MCP server with Claude Code
claude mcp add --scope user ai-team-memory \
  -e VOYAGE_API_KEY=<your-key> \
  -- /path/to/claude/rag/mcp-server/.venv/bin/python3 -m memory_mcp

Architecture:

Claude Code ──(stdio)──> MCP Server ──> Qdrant (Docker, port 6333)
                              │
                         Voyage AI (voyage-code-3, 1024-dim embeddings)

See: RAG Setup Guide | Knowledge Management

Context Persistence

Automatic session continuity — decisions, file changes, and error resolutions survive context compaction and are restored in future sessions.

How it works:

Distillation pipeline (distill_context.py): Promotes raw session context into permanent learnings and agent-knowledge collections — turning temporary conversation artifacts into long-lived institutional knowledge.

See: Context Persistence Guide

Multi-LLM Consultation (/all)

Query GPT-5-2, Gemini 3.1 Pro, Grok 4, and more from within Claude Code. Get consensus, divergent views, and synthesized recommendations.

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

9 models available (3 defaults, 6 alternatives):

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

Setup:

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 detects recurring patterns in accumulated learnings and proposes permanent SKILL.md updates — with human approval before any changes are applied.

/kai analyze                    # Scan learnings for patterns
/kai propose                    # Generate SKILL.md update proposals
/kai list --status pending      # Review pending proposals
/kai approve <ID>               # Approve a proposal
/kai apply <ID>                 # Apply to SKILL.md files
/kai status                     # Summary of all proposals

Pipeline: learnings → pattern detection → proposal generation → quality validation → human approval → SKILL.md update → re-ingest to Qdrant.

See: Kai Guide

Migration Between Laptops

Two scripts to move the entire framework (repo + skills + Qdrant data + MCP config) between machines:

# On source laptop — creates a single archive
./migrate-pack.sh
# → ai-dev-team-migration-20260319-143022.tar.gz

# Copy archive to new laptop, then:
./migrate-unpack.sh ai-dev-team-migration-20260319-143022.tar.gz
# Installs to current directory by default

# Or specify a target:
./migrate-unpack.sh archive.tar.gz --repo-dir ~/projects/ai-dev-team

What migrate-pack.sh archives:

• The ai-dev-team repository (excluding venvs, caches)
• ~/.claude/ config (skills, commands, templates, CLAUDE.md, settings)
• Project memory files
• Qdrant Docker volume data (if Qdrant is running)

What migrate-unpack.sh does:

1. Pre-flight check (Docker, Python 3.11+, Claude Code CLI)
2. Restore repo to target directory
3. Merge skills/commands into ~/.claude/ (keeps your extra agents, updates shared ones)
4. Start Qdrant and restore data
5. Create Python venvs and install dependencies
6. Prompt for API keys and register MCP servers

Your existing agents on the new laptop are preserved — the unpack script uses rsync merge (adds and updates, never deletes).

Repository Structure

ai-dev-team/
├── README.md                     # This file
├── CLAUDE.md                     # Repo-level instructions for Claude Code
├── install.sh                    # Interactive installer
├── migrate-pack.sh               # Pack for migration
├── migrate-unpack.sh             # Unpack on new laptop
│
├── claude/                       # Deployable content (installs to ~/.claude/)
│   ├── CLAUDE.md                 # Global instructions (TDD, approval gates)
│   ├── TEAM_WORKFLOW.md          # Complete team workflow spec
│   ├── skills/                   # 40 SKILL.md files across 9 categories
│   ├── commands/                 # 37 slash command definitions
│   ├── templates/                # 6 document templates
│   │
│   └── rag/                      # RAG Knowledge Base system
│       ├── docker-compose.yml    # Qdrant v1.13.2
│       ├── mcp-server/           # Custom MCP server (FastMCP, 4 tools)
│       ├── ingestion/            # SKILL.md → Qdrant pipeline
│       ├── context-cache/        # Session persistence (PreCompact/SessionStart hooks)
│       ├── kai/                  # Self-improving meta-agent
│       └── management/           # Admin: stats, backup, prune, reindex
│
├── multi-llm/                    # Multi-LLM consultation system
│   └── mcp/                      # MCP server (FastMCP, 3 tools, 9 models)
│
└── docs/                         # Extended documentation
    ├── TEAM_WORKFLOW.md
    ├── multi-llm-guide.md
    ├── kai-guide.md
    ├── context-persistence-guide.md
    ├── knowledge-management-guide.md
    ├── skill-extension-guide.md
    ├── agent-communication.md
    └── rag-setup/                # Setup, management, embedding providers

Extending the Framework

Adding a New Agent

1. Create a skill directory under the appropriate category:

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

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

   ---
   name: rust-developer
   description: "Senior Rust Developer with 8+ years systems programming experience"
   ---
   
   # Rust Developer
   
   ## Trigger
   Use when working with Rust code, systems programming, or performance-critical services.
   
   ## Context
   You are a Senior Rust Developer...
   
   ## Expertise
   ### Rust 2024 Edition
   - Ownership, borrowing, lifetimes
   ...
   
   ## Anti-Patterns
   - Never use `unwrap()` in production code
   ...
   

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

4. Re-install: ./install.sh --merge

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 (40 agents + 37 commands + 6 templates) works with just Claude Code — no additional dependencies.

Documentation

Testing

The RAG platform includes 203+ tests:

# Activate the RAG venv
cd claude/rag/mcp-server && source .venv/bin/activate

# Run all test suites
pytest                              # 20 MCP server tests
pytest ../ingestion/tests/          # 20 ingestion pipeline tests
pytest ../context-cache/tests/      # 75 context persistence tests
pytest ../kai/tests/                # 88 Kai meta-agent tests

# Multi-LLM tests (separate venv)
cd ../../../multi-llm/mcp
source .venv/bin/activate && pytest

Version History

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. Run tests if modifying RAG/Multi-LLM code
6. Submit a pull request

See Skill Extension Guide for detailed contribution guidelines.

License

MIT License — See LICENSE file for details.