These pages document master, which is unreleased and in development. The Quick Start installs the latest stable release; anything newer than that tag is marked in the text.
Spec-Driven Development vs Code Copilot Team
A side-by-side comparison of two complementary approaches to AI-assisted software development.
| Spec Kit (GitHub) | Code Copilot Team | |
|---|---|---|
| Category | Workflow methodology | Configuration framework |
| Focus | What to build | How to behave while building |
| Approach | Generates living documents (spec → plan → tasks → code) | Ships reusable rules, agents, hooks, templates, and remediation patterns |
Phase-by-Phase Mapping
Section titled “Phase-by-Phase Mapping”| SDD Phase | SDD Artifact | Code Copilot Team Equivalent |
|---|---|---|
| Constitution — project principles | /speckit.constitution → constitution.md |
shared/skills/*/SKILL.md (always-on skills) + template golden principles |
| Specify — requirements & intent | /speckit.specify → spec.md |
No direct equivalent — CCT assumes requirements exist |
| Plan — architecture & design | /speckit.plan → plan.md |
Research + Plan agents (Opus model, high effort) |
| Tasks — implementation breakdown | /speckit.tasks → tasks.md |
Build agent decomposes plan into bounded tasks (5–30 min) |
| Implement — code generation | /speckit.implement (one task at a time) |
Build agent with sub-agent delegation, or Ralph Loop for autonomous iteration |
| Clarify — resolve ambiguity | /speckit.clarify |
clarification-protocol.md rule enforced across all phases |
| Analyze — consistency check | /speckit.analyze |
Review agent (full phase with type checking, linting, test execution) |
| Quality validation | /speckit.checklist |
verify-app.md agent + verify-on-stop.sh hook (automatic) |
Unique Strengths
Section titled “Unique Strengths”What Spec Kit offers that Code Copilot Team doesn’t
Section titled “What Spec Kit offers that Code Copilot Team doesn’t”Specification generation — The /speckit.specify phase generates structured requirements (user stories, personas, entities, success criteria) from a high-level description. For greenfield projects where requirements are vague, this forces clarity before any technical planning begins.
Broad agent support — Works with 20+ AI agents (Claude, Codex, Cursor, Gemini, Copilot, Windsurf, Kiro, Roo, and more) via adapter-generated command files.
Living document pipeline — Creates a chain of versioned artifacts (constitution.md → spec.md → plan.md → tasks.md) where each phase reads the previous artifacts, keeping the full decision trail in files rather than chat history.
Feature-branch workflow — Organizes work into numbered feature directories (e.g., 001-photo-albums/) with git branch management per feature.
What Code Copilot Team offers that Spec Kit doesn’t
Section titled “What Code Copilot Team offers that Spec Kit doesn’t”Mechanical enforcement via hooks — Six lifecycle hooks run deterministically outside the agentic loop: type checking after every edit, test suite on stop, auto-formatting, file protection, and context re-injection. Enforcement is mechanical, not advisory.
Linter remediation feedback loop — 56 stack-specific patterns in remediation.json files inject fix instructions into the AI’s context when errors match golden principle violations. The error message itself teaches the AI how to self-correct.
Multi-agent team delegation — The Build phase delegates to specialized sub-agents (RAG Engineer, Frontend Dev, QA, etc.) with explicit file ownership and non-overlapping boundaries, enabling parallel work across domains.
Pre-built project templates — Seven opinionated templates (ml-rag, java-enterprise, web-dynamic, etc.) ship with architecture rules, agent team definitions, stack-specific conventions, and remediation patterns.
Ralph Loop (autonomous iteration) — Single-agent loop pattern (read PRD → implement → test → commit → repeat) with safety guards: max iterations, stuck detection, progress monitoring. No human review required per task.
Repository-native continuity — phase recaps, spec artifacts, and project docs keep context in versioned files instead of an external memory service.
Self-testing framework — ~580 automated tests covering hook correctness, generation pipeline integrity, structural validation, and remediation coverage.
Philosophical Differences
Section titled “Philosophical Differences”| Dimension | Spec Kit | Code Copilot Team |
|---|---|---|
| Core belief | “Specifications are executable” | “Every rule is failure-driven” |
| Planning cadence | Before every feature, from scratch | Once at setup, enforce continuously |
| Source of truth | Living documents (spec.md, plan.md) | Rules + templates + hooks (config files) |
| Enforcement model | Advisory (constitution.md) | Mechanical (hooks, linters, type checkers) |
| Agent architecture | Single agent, sequential tasks | Multi-agent team with delegation |
| Autonomy level | Human reviews every task | Ralph Loop runs autonomously |
| Reusability | Process is reusable; artifacts are per-project | Rules, agents, hooks, templates reusable across projects |
| Tool coverage | 20+ agents (broad) | 6 tools (deep integration) |
Common Ground
Section titled “Common Ground”Both frameworks address the same root problems — lost context, hallucinations, mid-project amnesia — from different angles:
- Upfront planning before coding. SDD’s specify → plan pipeline matches CCT’s Research → Plan phases. Both reject “figure it out as we go.”
- Single source of truth. SDD uses spec.md/plan.md. CCT enforces “the repository is the only source of truth” via
copilot-conventions.md. - Task decomposition. SDD’s
/tasksgenerates bite-sized work items. CCT’s Build agent decomposes plans into bounded tasks. Same principle, different mechanism. - Clarification over guessing. SDD offers
/speckit.clarify. CCT enforcesclarification-protocol.mdas a rule: “Ask before implementing ambiguous requirements.” - Test-driven quality. SDD advocates TDD as philosophy. CCT mechanically enforces it via
verify-on-stop.shandverify-after-edit.sh.
Pros and Cons
Section titled “Pros and Cons”Spec-Driven Development (Spec Kit)
Section titled “Spec-Driven Development (Spec Kit)”| Pros | Cons |
|---|---|
| Generates structured requirements from vague ideas | No runtime enforcement — constitution is advisory |
| Works with 20+ AI agents | No hooks or lifecycle scripts |
| Living document pipeline preserves full decision context | Single-agent sequential execution only |
| Feature-branch workflow for multi-feature projects | No pre-built project templates |
Low barrier to entry (specify init and go) |
No linter remediation or self-correction |
| Resonates with enterprise requirements-driven teams | No autonomous iteration mode |
Code Copilot Team
Section titled “Code Copilot Team”| Pros | Cons |
|---|---|
| Mechanical enforcement via 6 lifecycle hooks | No specification generation phase |
| 56 remediation patterns for AI self-correction | No structured requirements capture |
| Multi-agent delegation for parallel work | Supports 6 tools vs 20+ |
| 7 pre-built templates with architecture rules | More complex initial setup |
| Ralph Loop for autonomous iteration | Multi-agent delegation adds overhead for simple tasks |
| Multi-copilot support from single source of truth | Opinionated templates may not fit every stack |
| ~580 automated tests for the framework itself | |
| Versioned continuity via project artifacts |
Verdict: Complementary, Not Competing
Section titled “Verdict: Complementary, Not Competing”These frameworks address different halves of the AI-assisted development lifecycle:
Spec Kit Code Copilot Team───────── ──────────────────"What to build" "How to behave while building"
/specify → spec.md ──→ Research agent reads spec/plan → plan.md ──→ Plan agent refines with rules/tasks → tasks.md ──→ Build agent delegates tasks/implement → code ──→ Hooks enforce quality at every edit Remediation teaches the AI to self-correct verify-on-stop runs full test suiteThe ideal workflow combines both. Use Spec Kit to generate the specification and architecture. Then use Code Copilot Team’s agents, hooks, and remediation to implement it with mechanical quality enforcement.
Choosing one? If the AI keeps building the wrong thing → start with Spec Kit. If the AI keeps building the right thing badly → start with Code Copilot Team.