Generated banner for AI Team Orchestration
Generated logo for AI Team Orchestration

AI Team Orchestration

GitHubOfficialFirst committed by denis-a-evdokimovDistributed by GitHub

  • Skill
  • Meta (authoring, orchestration, planning, memory)
  • Agent tooling
  • MIT
  • No issues found

From the author

Bootstrap and run a lightweight multi-agent development team. Use when starting or adopting a project, planning work, coordinating implementation and optional QA, brainstorming with distinct perspectives, or preserving context across sessions.
— the description by denis-a-evdokimov

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

AI Team Orchestration provides a structured approach to managing software development tasks using specialized agent roles. By assigning distinct responsibilities to a Producer, Developer, and QA agent, the framework reduces blind spots and ensures that planning, implementation, and verification are handled by appropriate perspectives. It emphasizes proportional process, where the level of rigor scales with project risk, and promotes the use of durable project documentation to maintain context across sessions.

What it does

  • Defines roles for Producer, Dev, and QA agents to separate planning, execution, and verification.
  • Provides templates for project briefs, sprint plans, and brainstorming sessions.
  • Offers a structured method for cross-session context recovery.
  • Encourages proportional process management based on task risk.
  • Facilitates creative debate through multi-perspective brainstorming formats.
  • Integrates with existing repository policies and tools without requiring hardcoded configurations.

When to use it

  • When starting a new project or adopting an existing codebase.
  • When planning complex or multi-step development tasks.
  • When you need to brainstorm architectural or product decisions with diverse perspectives.
  • When you need to maintain project context across multiple AI sessions.
  • When you require independent verification of code changes.

Advantages

  • Reduces groupthink by requiring distinct agent perspectives and disagreements.
  • Scales process intensity based on actual project risk rather than rigid ceremony.
  • Ensures durable documentation of decisions and progress within the repository.
  • Maintains flexibility by inheriting the developer's existing tools and model preferences.
  • Improves code quality through independent QA and self-review cycles.

Usage examples

“Run a team brainstorm about the new user authentication flow.”
The agent orchestrates a debate between multiple personas (e.g., Designer, Security, QA) to produce a design note with pros, cons, and estimated effort.
“Read the repository instructions and continue from the recorded next action in the sprint plan.”
The agent recovers the project state, identifies the pending task, and resumes the development workflow.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/github/ai-team-orchestration/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip ai-team-orchestration.zip -d .agents/skills

Documentation by denis-a-evdokimov

AI Team Orchestration

Use three stable agents:

AgentPurpose
@ai-team-producerClarify scope, plan proportionately, coordinate, and merge
@ai-team-devImplement, test, self-review, and prepare the pull request
@ai-team-qaIndependently test behavior when dedicated QA is useful

Nova, Sage, and Milo are perspectives inside the Dev agent, not mandatory project layers.

Default Workflow

Plan -> Implement -> Test -> optional review or QA -> Merge -> update project state

Keep the workflow proportional:

  • Skip formal planning for small, obvious changes.

  • Use a short plan for multi-step or cross-cutting work.

  • Add independent review or QA when risk, uncertainty, or repository policy justifies it.

  • Let branch protection, required checks, permissions, and merge queues enforce repository merge policy.

Start or Adopt a Project

  1. Read existing repository instructions and documentation.

  2. Discover the actual stack, architecture, commands, deployment model, and risks.

  3. Create or update PROJECT_BRIEF.md only when durable cross-session context is useful. Start from the project brief template and omit irrelevant sections.

  4. For substantial work, create a concise plan from the sprint plan template.

  5. Use a separate branch or clone when parallel sessions could conflict, following the repository's own Git policy.

Execute

Producer
  • Define the outcome, constraints, acceptance criteria, and explicit exclusions.

  • Choose review and QA based on risk rather than ceremony.

  • Keep durable project state concise and current.

Dev
  • Follow repository conventions and implement the smallest complete solution.

  • Run relevant checks and inspect the final diff.

  • Open or update the pull request with summary, verification, and limitations.

QA
  • Use only when dedicated behavioral verification adds value.

  • Test the requested change and important regressions.

  • Report reproducible findings and verify fixes.

Brainstorms

Use the brainstorm format for product or architecture decisions that benefit from competing perspectives. For ordinary implementation choices, let Dev decide using repository conventions.

Context Recovery

Before ending a long or interrupted session:

  1. Update the active plan or progress note if one exists.

  2. Record material decisions, blockers, and the next action in repository context.

  3. Use a cold-start prompt such as:

Read the repository instructions, then read whichever sources exist for this
work: the active issue or request, PROJECT_BRIEF.md, and the active plan or
progress note.
Continue from the recorded next action.

Tool and Model Inheritance

The bundled agents intentionally omit tools and model frontmatter:

  • available built-in, MCP, and extension tools remain usable;

  • developers keep control of model selection;

  • role boundaries are defined by instructions and normal trust, permission, authentication, and approval controls.

If the environment exposes too many tools, deselect irrelevant tools or MCP servers, or use VS Code virtual-tool management. Do not add a machine-specific plugin allowlist.

Principles

  • Prefer working software and clear handoffs over process artifacts.

  • Follow repository policy instead of embedding universal Git commands.

  • Preserve unknown work and ask before destructive or privileged actions.

  • Keep bugs and important decisions in durable project systems, not only chat.

  • See anti-patterns for concise lessons.

Files

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of denis-a-evdokimovdenis-a-evdokimov
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/ai-team-orchestration · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
denis-a-evdokimov, sinamorida

AutoGineer is not affiliated with or endorsed by denis-a-evdokimov or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download ai-team-orchestration.zip