convez.ai
MCP ServerAutomaçãoAvançado
olehsvyrydov

Time de Desenvolvimento AI

olehsvyrydov/AI-development-team

Time de agentes especialistas com workflow enforçado para desenvolvimento profissional

Ver no GitHub
BomPluginScore · de 0 a 100

Servidor MCP que implementa um time de ~48 agentes especialistas em sua IDE (Claude Code, Cursor, Kiro, VS Code) com workflow enforçado e portões de aprovação. Oferece processos estruturados em vez de prompts soltos, com roles especializadas e referências de stacks tecnológicos sob demanda.

Instalação

$npx convez-ai olehsvyrydov/AI-development-team

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
19
Forks
8
Acompanhando
0
Saúde
71%
Último commit
há 1 semana
Versão
—
Issues abertas
1
Contribuidores
1

Casos de uso

  • Organizar fluxos de desenvolvimento complexos com aprovações obrigatórias
  • Estruturar trabalho em equipes usando agents especializados por função
  • Executar processos de code review e QA com gatilhos automáticos

Veredito

Ferramenta robusta para equipes que precisam de processos rigorosos com agents, não apenas prompts. A arquitetura de skills reutilizáveis e workflow-engine enforçado é uma abordagem sólida, mas exige curva de aprendizado e manutenção ativa de yamls de workflow.

README

A tradução para o português deste README ainda está na fila.

AI Development Team

Claude Code Cursor Kiro VS Code License: MIT Stars

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

One mega-promptAI Dev Team
Processhope it remembersenforced gates that can refuse to proceed
Right-sizingsame weight for a typo and a featureproportional (change-class + presets)
Expertiseone generalistrole specialists + on-demand stack references
Lock-inoften tool-specificvendor-neutral, 4 editors, free defaults

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:

EditorWhat it installs
Claude Code.claude/skills + .claude/commands + CLAUDE.md
Cursor.cursor/rules/ai-dev-team.mdc + AGENTS.md
Kiro.kiro/steering/ai-dev-team.md + AGENTS.md
VS Code (Copilot).github/copilot-instructions.md + AGENTS.md
./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

CommandAliasRoleKey Expertise
/po/maxProduct OwnerVision, backlog, user stories, prioritization
/sm/ludaScrum MasterSprint ceremonies, AC refinement, team orchestration
/ba/annaBusiness AnalystMarket research, requirements, gap analysis
/arch/jorgeSolution ArchitectSystem design, patterns (CQRS, Saga), ADRs
/fe/finnFrontend DeveloperReact 19, Next.js, TypeScript, TailwindCSS
/be/jamesBackend DeveloperJava 21+, Spring Boot 4, Kotlin, reactive APIs
/rev—Code ReviewerQuality, security, style, requirements validation
/qa/robQA EngineerTest case design, BDD specs, exploratory testing
/e2e/adamE2E TesterPlaywright, Detox, performance testing
/ui/auraUI/UX DesignerDesign systems, Figma-to-code, accessibility
/secops/sorenSecurity EngineerOWASP, threat modeling, Zero Trust, supply chain
/fin/ingaUK AccountantTax planning, VAT, R&D credits, MTD compliance
/legal/alexUK Legal CounselGDPR, contracts, employment law, compliance
/mkt/apexMarketing StrategistGTM strategy, positioning, content, SEO
/devops—DevOps EngineerTerraform, Kubernetes, GitHub Actions, Docker

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

CommandRoleKey Expertise
/aiAI/LLM Application EngineerRAG, agents, prompt engineering, evals, tool use, guardrails
/mlopsMLOps EngineerModel serving, ML/AI pipelines, deployment & monitoring
/dataData EngineerETL/ELT, dbt, warehouses, streaming, orchestration
/dbaDatabase AdministratorSchema design, indexing, query tuning, safe migrations
/sreSRE / ObservabilitySLOs, monitoring, alerting, incident response, runbooks
/perfPerformance EngineerWeb Vitals, profiling, caching, load testing, budgets
/androidNative Mobile — AndroidKotlin, Jetpack Compose, Play delivery
/iosNative Mobile — iOSSwift, SwiftUI, App Store delivery
/uxUX ResearcherInterviews, usability testing, personas, journey maps
/twTechnical WriterAPI docs, Javadoc/JSDoc, READMEs, diagrams, onboarding

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:

SkillExtendsTechnology
Angular DeveloperFrontendAngular 21, Signals, NgRx SignalStore
Vue DeveloperFrontendVue 3, Composition API, Pinia, Nuxt 3
Flutter DeveloperFrontendFlutter/Dart, Riverpod, Material 3
Kotlin DeveloperBackendKotlin 2.1, Coroutines, KMP
Quarkus DeveloperBackendQuarkus, Panache, GraalVM Native
FastAPI DeveloperBackendPython FastAPI, async, Pydantic v2
Laravel DeveloperBackendPHP/Laravel, Eloquent, Filament, Livewire 3
Spring KafkaBackendKafka 4.x, Reactor Kafka, DLT/retry
JavaFX DeveloperDesktopJavaFX 21+, FXML, Scene Builder
GraphQL DeveloperArchitectApollo, Federation, DataLoader
Terraform SpecialistDevOpsMulti-cloud IaC, state management
Cucumber BDDE2E TesterGherkin, step definitions, Cucumber-JVM/JS
HMRC APIBackendUK Making Tax Digital, OAuth2 Gateway
Backend ReviewerReviewerJava/Kotlin focus, Checkstyle, SonarQube
Frontend ReviewerReviewerTypeScript focus, ESLint, accessibility
PHP ReviewerReviewerPHP/Laravel focus, PHPStan, Psalm
Backend TesterTesterJUnit 5, Testcontainers, StepVerifier
Frontend TesterTesterJest, React Testing Library, Vitest
JavaFX DesignerUI DesignerJavaFX CSS, FXML layouts
UK AccountantAccountantUK-specific tax, HMRC, IR35
UK Legal CounselLegalEnglish & Welsh Law, GDPR UK
UK Self-EmploymentUK AccountantSA103, Class 4 NI, MTD quarterly

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

GateAgentWhen Required
Architecture/archWhen triggered (new system / dependency / boundary) or forced by preset
Security/secopsWhen triggered (auth / secrets / PII / external input) — never skipped for size
Finance/finPayments, billing, VAT, tax features
Legal/legalGDPR, privacy, contracts, employment
UI Design/uiFrontend features

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

ComponentRequiredVersion
Claude CodeYesLatest
PythonFor Multi-LLM only3.11+
OpenRouter API keyFor Multi-LLM onlyPay-per-use

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


Documentation

GuideDescription
Team WorkflowComplete phase-by-phase development process
Context PersistenceSession continuity notes
Multi-LLM Guide/all command, model registry, API setup
Skill ExtensionAdding new technologies and agents
Agent CommunicationHandoff specs, artifact flow between agents
ArchiveWhat was set aside (the DART dashboard product) and where to find it

Version History

See CHANGELOG.md for full details.

VersionDateChanges
5.1.02026-06-14Reference libraries (ai-engineer, architect, data/mlops/dba); /tw + /mlops wired up; roster reconciled to core 15; knowledge-backend naming generalized; DART dashboard + RAG subsystem + migration scripts removed
5.0.02026-06-06OSS-first release — proportional workflow engine, 48→29 roster, universal multi-editor installer, pluggable adapters
4.1.02026-02-24Kai meta-agent, multi-LLM consultation, migration scripts
4.0.02025-01-02Restructured for easy ~/.claude deployment, installer
3.1.02024-12-27Approval gates, design verification
3.0.02024-12-26TDD workflow, unified QA agents
2.0.02024-12-25Performance testing modules
1.0.02024-12-23Initial release with 15 agents

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.

Ver o original no GitHub

Bom para

Relacionados