GitHub Copilot Agent Coordinator

This skill intelligently assigns GitHub issues to the most appropriate GitHub Copilot agent(s) based on issue type, labels, technical domain, and dependencies.

When to Use This Skill

Auto-trigger when:

• User says: "Assign agents to these issues"
• User says: "Who should work on #123?"
• User says: "Route this to the right agent"
• User says: "Match agents to issues"
• After creating issues via github-mcp-orchestrator skill
• When reviewing a backlog and planning work assignment

Manual trigger:

• When you need to determine which Copilot agent is best suited for specific work
• When coordinating work across multiple specialized agents

Mission

Analyze GitHub issues and assign them to the most appropriate GitHub Copilot agent(s) from the available agent pool. Ensure:

1. Right agent for the right task - Match issue requirements to agent expertise
2. Dependency-aware assignment - Respect issue dependencies and execution order
3. No conflicts - Don't assign blocked issues; wait for dependencies
4. Clear handoff - Provide context and acceptance criteria to agents
5. Actual Copilot assignment - Use mcp__github__assign_copilot_to_issue to assign agents automatically

Available Agents

The repository has 25+ specialized GitHub Copilot agents. See reference/agent-catalog.md for the complete list and capabilities.

Key Agent Categories

• Frontend specialists: React, Tailwind UI, shadcn components, mobile responsive
• Backend specialists: Express API, Drizzle database, authentication
• Quality specialists: Testing, code review, refactoring, performance
• Integration specialists: Spotify API, security, realtime features
• DevOps specialists: CI/CD, dependency management, git workflow
• Documentation specialists: README, API docs, accessibility

Assignment Strategy

1. Parse Issue

Extract from the issue:

• Type: feature, bug, chore, test, docs
• Area: frontend, backend, database, infra, integration
• Labels: All assigned labels
• Dependencies: Blocked by or depends on other issues
• Complexity: Estimate from issue description and acceptance criteria

2. Match to Agent

Use the matching logic in reference/agent-matching-rules.md:

• Type + Area combination → Primary agent
• Cross-cutting concerns → Secondary agent(s)
• Review requirements → Add Code Review Specialist

Examples:

Issue: "Add user notification preferences UI"
Labels: type:feature, area:frontend, estimate:m
→ Primary: React Specialist
→ Secondary: Form Handling Specialist, Tailwind UI Specialist
→ Review: Code Review Specialist

Issue: "Fix database N+1 query in dashboard"
Labels: type:bug, area:database, priority:p1
→ Primary: Database Specialist
→ Secondary: Performance Specialist
→ Review: Code Review Specialist

Issue: "Add Playwright tests for checkout flow"
Labels: type:test, area:frontend, estimate:l
→ Primary: Testing Specialist
→ Secondary: Mobile Responsive Specialist
→ Review: Code Review Specialist

3. Check Dependencies

Before assignment:

• If blocked: Mark as status:blocked, do NOT assign agent
• If unblocked: Assign agent with status:ready
• If in dependency chain: Note execution order in issue comment

4. Assign Copilot Agent

For unblocked issues:

A. Assign via GitHub API Use mcp__github__assign_copilot_to_issue to actually assign GitHub Copilot to the issue. This triggers the agent to start work.

B. Add Assignment Comment Add a comment to the issue with context:

## 🤖 Agent Assignment

**Assigned**: GitHub Copilot
**Specialist Mode**: [Agent Name] (e.g., React Specialist, Backend API Specialist)
**Supporting Context**: @[agent-name], @[agent-name]

### Context
[Brief summary of what needs to be done]

### Key Files to Focus On
- `path/to/file.ts`
- `path/to/component.tsx`

### Acceptance Criteria
- [ ] [Criterion from issue]
- [ ] [Additional criteria]

### Dependencies
- Depends on #123 (must complete first)
- Related to #124 (can work in parallel)

### Testing Requirements
- Unit tests for new functions
- E2E tests for user flow
- Manual testing checklist in issue

**Status**: ✅ Copilot assigned and ready to start

C. Update Issue Labels Add status:assigned label to track assignment.

If blocked:

## ⏳ Agent Assignment Pending

**Status**: 🚫 Blocked

This issue depends on:
- #123 Database schema changes
- #124 API endpoint implementation

**Planned Agent**: React Specialist (will assign when unblocked)

Workflow

1. Intake

• Receive issue number(s) or list of issues to assign
• Fetch issue details via GitHub MCP
• Parse labels, description, acceptance criteria

2. Agent Discovery

• Read agent catalog from reference/agent-catalog.md
• Apply matching rules from reference/agent-matching-rules.md
• Consider multi-agent scenarios

3. Dependency Check

• Read dependency graph from issues
• Verify dependencies are complete
• Determine if issue is ready for assignment

4. Assignment

For each unblocked issue:

A. Assign Copilot via API

mcp__github__assign_copilot_to_issue({
  owner: "{owner}",
  repo: "{repo}",
  issueNumber: 123
})

B. Add Context Comment

mcp__github__add_issue_comment({
  owner: "{owner}",
  repo: "{repo}",
  issue_number: 123,
  body: "## 🤖 Agent Assignment\n\n**Assigned**: GitHub Copilot\n..."
})

C. Update Labels Use issue_write method to add status:assigned label

D. Track assignment in output summary

5. Output Summary

Generate assignment report:

## Agent Assignment Summary

### Assigned (Ready to Start)
- #124 → Database Specialist (no blockers)
- #126 → React Specialist + Form Handling Specialist (no blockers)

### Blocked (Waiting on Dependencies)
- #125 → Backend API Specialist (blocked by #124)
- #127 → Testing Specialist (blocked by #125, #126)

### Execution Order
1. Start #124, #126 in parallel
2. After #124 completes → start #125
3. After #125 and #126 complete → start #127

### Next Steps
1. Agents can begin work on #124 and #126 immediately
2. Monitor #124 progress; assign #125 when complete
3. Monitor #125 and #126; assign #127 when both complete

Assignment Rules

Rule 1: One Primary Agent

• Every issue gets ONE primary agent responsible for implementation
• Primary agent "owns" the issue from start to finish

Rule 2: Optional Supporting Agents

• Complex issues may need 1-2 supporting agents for specific expertise
• Supporting agents provide guidance, not full implementation

Rule 3: Always Include Code Review

• Every code-producing issue must be reviewed by Code Review Specialist
• Review happens after implementation, before PR merge

Rule 4: No Assignment When Blocked

• Never assign agents to blocked issues
• Track planned assignment for when dependencies clear

Rule 5: Consider Cross-Cutting Concerns

Issues involving:

• Security: Always include Security Specialist
• Performance: Consider Performance Specialist for data-heavy features
• Accessibility: Include Accessibility Specialist for UI work
• Mobile: Include Mobile Responsive Specialist for responsive features

Integration with Other Skills

After github-mcp-orchestrator

When issues are created via the orchestrator skill:

1. Orchestrator creates epic + children
2. This skill (coordinator) automatically assigns agents
3. Output includes both issue map AND agent assignments

Before copilot-workflow-orchestrator

When complex multi-agent workflows are needed:

1. This skill assigns agents to individual issues
2. Workflow orchestrator manages sequencing and handoffs
3. Progress tracker monitors execution

Reference Documentation

• Agent catalog: See reference/agent-catalog.md
• Matching rules: See reference/agent-matching-rules.md
• Assignment templates: See templates/assignment-comment.md

What This Skill Does

• Analyzes issues for technical domain and complexity
• Matches issues to best-fit Copilot agents
• Checks dependencies before assignment
• Creates agent assignment comments on issues
• Tracks assignment status across multiple issues
• Provides execution order recommendations

What This Skill Doesn't Do

• Doesn't write code (agents do that)
• Doesn't manage agent execution (that's orchestrator)
• Doesn't review code (Code Review agent does that)
• Doesn't create issues (github-mcp-orchestrator does that)