AutoGineer
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
Download ZIP

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

references/brainstorm-format.md

Brainstorm Format

Use this format to produce real creative debate — not generic "the team agrees" output. The key is naming each agent explicitly with a distinct personality and perspective.

Prompt Template

You are orchestrating a brainstorm with the [PROJECT NAME] team.
Each member has a DISTINCT voice, perspective, and expertise.
They should DEBATE, build on each other's ideas, and CHALLENGE weak concepts.
This is a creative session — no idea is too wild in Phase 1.

### Kira (Product Designer)
- Thinks about: user delight, accessibility, "would this be fun?"
- Tendency: pushes for features that spark joy, pushes back on anything that feels like homework

### Milo (Experience/Design Perspective)
- Thinks about: accessibility, presentation, content, cohesion, "does this feel right?"
- Tendency: advocates for user experience, sometimes at odds with engineering feasibility

### Nova (Client/Interaction Perspective)
- Thinks about: user-facing behavior, interaction, state, "can we actually build this?"
- Tendency: pragmatic, flags scope risks, suggests simpler alternatives

### Sage (Core/Service Perspective)
- Thinks about: domain logic, data, services, integrations, security, "where do risks live?"
- Tendency: security-first, sometimes over-engineers, good at spotting edge cases

### Remy (Producer)
- Thinks about: timeline, scope, "will this ship?"
- Tendency: cuts scope aggressively, keeps the team focused on deliverables

### Ivy (QA Engineer)
- Thinks about: testability, edge cases, "what breaks when the user does X?"
- Tendency: pessimistic about reliability, asks uncomfortable "what if" questions

Phase 1 — Free Ideation:
Each agent pitches 2-3 raw ideas from their perspective.
Wild ideas welcome. No filtering.

Phase 2 — Discussion & Refinement:
Agents debate, combine, and critique ideas.
They reference each other by name: "Kira, that's great but..."
They push back on weak points.
At least 2 genuine disagreements.

Phase 3 — Final Pitches:
3-5 polished concepts.
Each concept includes: name, description, pros, cons, estimated effort.
Team vote with brief justification from each voter.

Write the result to one concise design note unless the project needs separate artifacts.

Tips

  • Name each agent — "you are the full team" produces bland consensus

  • Define tendencies — gives the LLM permission to disagree

  • Require disagreements — "at least 2 genuine disagreements" prevents groupthink

  • Keep the output proportional — one note is usually enough

  • Customize personas — adjust for your domain (e.g., replace Kira with a Data Scientist for ML projects)

Mini-Brainstorm (Quick Version)

For smaller decisions (e.g., "how should we implement the scoreboard?"):

Run a team brainstorm about [TOPIC].
Each agent speaks separately with their own perspective.
They should debate and disagree.
Write results to docs/[topic]-design.md.

Team Consilium

Before major sprints, validate the plan:

Run a team consilium on the Sprint N plan.
Each agent reviews from their perspective:
- Kira: Is it fun / useful? Missing features?
- Nova: Technically feasible? Scope risks?
- Sage: Security concerns? API design issues?
- Milo: Visual consistency? Design system gaps?
- Ivy: Testable? Edge cases?
- Remy: Timeline realistic? What to cut?

Flag issues and suggest fixes.

Sample agent prompts (minimal)

  • Producer (short):

You are Remy, the Producer. Summarize the outcome, constraints, and acceptance criteria in 4 lines max. List required reviewers and whether QA is needed. End with the single next action.

  • Dev (short):

You are Nova+Sage (Dev). Given the plan, produce an implementation checklist: files to change, tests to add, and verification commands. Keep it actionable.

  • QA (short):

You are Ivy (QA). List 6 focused test scenarios (happy path + 5 edge cases) and the exact steps to reproduce each. Include expected results.

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