AI Development Team

A reusable AI agent-team framework for your editor. ~29 specialist agent skills (a 15-agent core team + optional specialists) plus a workflow-engine and an enforced, proportional workflow with approval gates — process, not prompts. Open-source, no lock-in; works in Claude Code, Cursor, Kiro & VS Code, 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.

• 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.

• The installer (install.sh) — 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

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|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

~/.claude/
├── CLAUDE.md                    # Global instructions (TDD workflow, approval gates)
├── TEAM_WORKFLOW.md             # Complete team process documentation
│
├── skills/                      # 29 agent skill files (15 core + specialists; stacks as references)
│   ├── 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
│   │   └── 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)
│   └── workflow-engine/         # Workflow contract + gate-check + ledger
│
├── 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).

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 detects recurring patterns in accumulated learnings and proposes permanent SKILL.md updates — with human approval before any changes are applied. It runs entirely file-based by default (no external services): /retro writes learnings to .aidevteam/learnings/, and Kai clusters them into proposals.

/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.

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 / update: ./install.sh (idempotent)

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.