Copilot Agent Coordinator

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)