Skip to main content
The GitHub Copilot Agent Toolkit provides a structured, iterative workflow for building features through three specialized agents. This approach reduces ambiguity, prevents rework, and ensures that careful planning translates into systematic implementation.

​
The Three Phases

The agent workflow follows a sequential, spec-driven development process:
1

Requirements (Phase 1)

Gathers, clarifies, and documents product requirements before any technical design begins.Agent: 📋 Requirements
Output: specs/features/{NNN}-{feature-name}/requirements.md
2

Plan (Phase 2)

Transforms approved requirements into a comprehensive technical design blueprint.Agent: 📝 Plan
Output: specs/features/{NNN}-{feature-name}/plan.md
3

Task (Phase 3)

Converts approved requirements and design into actionable implementation tasks.Agent: ✅ Task
Output: specs/features/{NNN}-{feature-name}/tasks.md

​
Why Three Phases?

This separation ensures each aspect of development gets proper attention:

Clarity First

Requirements phase eliminates ambiguity before technical decisions are made

Design Quality

Technical design phase explores architecture without rushing to code

Execution Plan

Task phase creates clear, dependency-aware implementation steps

​
Phase Boundaries

Each phase has strict boundaries to prevent overlap and maintain focus:
Allowed:
  • Product requirements and user stories
  • Acceptance criteria (EARS format)
  • Constraints and dependencies
  • Scope boundaries (in-scope vs out-of-scope)
Forbidden:
  • System architecture decisions
  • Technical implementation details
  • Task breakdowns or coding checklists
Allowed:
  • System architecture and component design
  • Technical decisions and tradeoffs
  • Data models and interface contracts
  • Implementation sequencing strategy
Forbidden:
  • Requirement redefinition (must loop back to Phase 1)
  • Executable coding task checklists
Allowed:
  • Concrete coding tasks with checkboxes
  • Task dependencies and parallelization
  • File/component modification lists
  • Verification criteria per task
Forbidden:
  • New requirement scope (must loop back to Phase 1)
  • New architecture decisions (must loop back to Phase 2)
  • Product code implementation

​
Traceability System

Each phase produces identifiers that trace through the workflow: 
# Requirements Phase
REQ-1: User must be able to export data in CSV format
REQ-2: System shall validate data before export

# Plan Phase  
DES-1: CSV export service (maps to REQ-1)
DES-2.1: Input validation layer (maps to REQ-2)
DES-2.2: Error handling strategy (maps to REQ-2)

# Task Phase
- [ ] 1.1 Implement CSV export service
  - Requirements: REQ-1
  - Design: DES-1
This traceability ensures:
  • Every technical decision maps to a requirement
  • Every task implements a design component
  • Nothing is built without clear justification
Iterative, Not Waterfall: While phases are sequential, each phase is internally iterative. Agents cycle through Discovery → Alignment → Drafting → Refinement until the user approves.

​
Golden Rules

All three agents follow these principles from AGENTS.md:
  1. Make small, correct, reviewable changes — Prefer the simplest solution that fits existing patterns
  2. Keep diffs minimal — Don’t refactor unrelated code
  3. Prefer existing repo patterns over general best practices
  4. Don’t add dependencies unless clearly necessary (explain why)
  5. Use skills — Leverage project-specific skills in .github/skills for best practices

​
When to Use This Workflow

Use the 3-phase workflow for:
  • New features requiring cross-cutting changes
  • Complex refactors with unclear scope
  • Ambiguous requests needing clarification
  • Collaborative projects where documentation matters
For simple, well-defined changes, you may skip directly to implementation.

​
Next Steps

Learn the Workflow

See how to use the 3-phase workflow in practice

Requirements Phase

Deep dive into gathering and documenting requirements

Build docs developers (and LLMs) love

Get started for freeTalk to us