To use specification-driven development with an AI coding agent, first describe the feature’s purpose and expected behavior, then have the agent help turn that intent into a reviewed specification. Add the project’s technical constraints in a plan, break the work into ordered tasks, implement in reviewable increments, and check the finished code against the requirements. This keeps decisions visible before the agent starts coding—and gives you a concrete way to find what it missed.
How do I use specification-driven development with an AI coding agent?
GitHub Spec Kit describes its core workflow as Specify → Plan → Tasks → Implement → Converge. The names of commands and how you invoke them depend on the agent integration, but the sequence is useful with other coding agents too: agree on what to build, decide how it fits the codebase, divide the work, implement it, and check for gaps.
- Set project principles. Record durable conventions—such as security expectations, accessibility standards, or architectural rules—in project context. These principles guide later work but do not replace the requirements for a particular feature.
- Specify the feature. Describe who needs it, the problem it solves, expected behavior, important user journeys, and what success looks like. Keep this focused on what should happen and why. Ask the agent to list assumptions and unanswered questions instead of silently filling them in.
- Clarify consequential ambiguity. Resolve questions that could change the behavior, permissions, edge cases, or acceptance criteria. Update the specification with the decisions before asking for a technical design.
- Plan the implementation. Supply the required stack, architecture, integration boundaries, performance limits, security or compliance needs, and relevant conventions in the existing project. Ask the agent to explain how the accepted requirements fit those constraints.
- Check quality and consistency. For higher-risk work, review the requirements for missing cases and compare the specification, plan, and tasks for conflicts or gaps. Correct the underlying artifacts and repeat the review before implementation.
- Create ordered tasks. Ask for small, concrete steps with dependencies and completion criteria. A task should be narrow enough to inspect and test, not a vague instruction such as “finish the feature.”
- Implement in increments. Have the agent work through the tasks one at a time. Parallel work can make sense when tasks are genuinely separable, but review each change and verify its behavior; generated artifacts are guidance, not proof of correctness.
- Converge against the intent. Compare the code with the specification, plan, and task list. If a requirement is missing or behavior differs, add or revise tasks, make the correction, and check again.
For straightforward work, the Spec Kit quickstart’s shorter route is constitution, specify, plan, tasks, implement, and converge. For a production feature or one with significant uncertainty, insert clarification, a requirements checklist, and cross-artifact analysis before coding. Choose gates based on ambiguity and consequence; ceremony is not the goal. See the Spec Kit quickstart and its Agentic SDD reference.
What should go in a software feature spec?
Keep user-facing intent separate from implementation decisions. That distinction makes it easier to discuss what users need before settling how a particular codebase will deliver it.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
| Artifact | Put this here | Keep this distinction clear |
|---|---|---|
| Specification | User-facing behavior, goals, user stories, outcomes, edge cases, and acceptance expectations | Explain what should happen and why; avoid committing prematurely to a technology stack. |
| Plan | Technology stack, architecture, integration strategy, technical constraints, and design decisions | Explain how the accepted requirements should fit the system. |
| Tasks | Ordered implementation steps, dependencies, and concrete completion criteria | Keep work small enough to inspect, test, and revise. |
| Verification record | Checks performed, observed results, remaining gaps, and follow-up tasks | Record evidence actually observed; do not claim success because an agent generated or ran a test. |
The first three artifacts follow the distinctions in the quickstart and GitHub’s explanation of the workflow. A verification record is a practical way to preserve human oversight, not a guarantee that the process makes the code correct.
Should I write a spec before asking AI to code?
For a multi-requirement feature, yes—but you do not need to arrive with a perfect document. You can start with a concise description of the problem and intended outcome, then ask the agent to draft a specification, expose assumptions, and identify unanswered questions. Review and correct that draft before moving into technical planning.
A one-line prompt can leave important behavior unstated, especially when the agent must work within an existing architecture or organizational constraints. GitHub presents specification-driven development for greenfield projects, feature work in existing systems, and legacy modernization. Those are intended use cases, not independent evidence that the method improves delivery speed or software quality.
When a short path is enough
Use the core specify, plan, tasks, implement, and converge sequence when behavior is familiar, the consequences of an incorrect assumption are low, and the result is easy to inspect. Keep the project principles and acceptance expectations explicit, even when the artifacts are brief.
When to add more gates
Add targeted clarification and consistency reviews when requirements are ambiguous, permissions or edge cases matter, or the feature is production-critical. A thorough process cannot rescue a mistaken requirement or an incomplete plan; a person still needs to make the requirement decisions and inspect the implementation.
How should the process change for an existing codebase?
For an existing project, the plan should account for local conventions and system boundaries, not just the requested feature. Give the agent relevant repository context and make integration expectations explicit: where the feature belongs, what existing behavior must remain stable, which components it touches, and what interfaces it must preserve. The specification still describes user outcomes; the plan explains how those outcomes fit the actual system.
Also decide how artifacts stay current when requirements change. Spec Kit’s documentation does not prescribe a universal policy for maintaining or changing spec.md, plan.md, and tasks.md. Teams should choose how a changed requirement updates those documents and the implementation tasks, rather than letting the code and written intent drift apart.
When separate components expose interfaces to outside consumers, the Spec Kit concept documentation points to contract-driven development: agree on observable obligations before implementing either side. See What is Spec-Driven Development?
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesHow do I set up Spec Kit with an AI coding agent?
Spec Kit’s documentation lists integrations including GitHub Copilot and Codex, along with a generic integration for other tools. The supported integration list and invocation syntax can change, so consult the current integration documentation rather than relying on a fixed list.
Rank #4
The documented installation route uses Python package tooling. For example, the installation guide shows:
uv tool install specify-cli
specify init my-project --integration copilotReplace copilot with the integration you intend to use. If the project already exists and is non-empty, follow Spec Kit’s installation guide and its existing-project instructions; the guide describes a force option that acknowledges a merge warning. Git is optional for the core setup and required only if you enable the Git extension.
Command spelling also varies: the reference documents /speckit-* for Copilot’s skills mode and $speckit-* for Codex and some other agents. Check the integration and installation pages for the current command and version guidance before using them.
Best Value
How do I know the agent followed the specification?
Do not treat a completed task list or a successful-looking response as verification. Check the implementation against the promised behavior, inspect the changes, and run appropriate checks for the project. Record what you actually checked, what happened, and any remaining gaps; create follow-up tasks for omissions instead of marking the feature complete by assumption.
GitHub summarizes the developer’s role this way: “The AI generates the artifacts; you ensure they’re right.” No independent effectiveness statistic or controlled comparison is identified in the cited official materials, so specification-driven development should be understood as a way to make requirements and review more explicit—not as a guarantee of better outcomes.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
