<?xml version="1.0" encoding="utf-8"?>
<entry xmlns="http://www.w3.org/2005/Atom" xml:base="https://docs.spec-kitty.ai/context/spec-driven/">
  <id>https://docs.spec-kitty.ai/context/spec-driven/</id>
  <title>Specification-Driven Development (SDD)</title>
  <updated>2026-11-13T00:00:00.000Z</updated>
  <author><name>Spec Kitty</name></author>
  <link rel="alternate" type="text/html" href="https://docs.spec-kitty.ai/context/spec-driven/"/>
  <summary>Specification-Driven Development methodology behind Spec Kitty — how executable specifications and implementation plans generate code, inverting the code-first power structure.</summary>
  <content type="html">&lt;span id=&quot;specification-driven-development-sdd&quot;&gt;&lt;/span&gt;
&lt;blockquote&gt;
&lt;p&gt;This guide is maintained as part of Spec Kitty, inspired by GitHub’s &lt;a href=&quot;https://github.com/github/spec-kit&quot;&gt;Spec Kit&lt;/a&gt;. We preserve attribution to the original authors while expanding the methodology.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;the-power-inversion&quot;&gt;The Power Inversion&lt;/h2&gt;
&lt;p&gt;For decades, code has been king. Specifications served code—they were the scaffolding we built and then discarded once the “real work” of coding began. We wrote PRDs to guide development, created design docs to inform implementation, drew diagrams to visualize architecture. But these were always subordinate to the code itself. Code was truth. Everything else was, at best, good intentions. Code was the source of truth, and as it moved forward, specs rarely kept pace. As the asset (code) and the implementation are one, it’s not easy to have a parallel implementation without trying to build from the code.&lt;/p&gt;
&lt;p&gt;Spec-Driven Development (SDD) inverts this power structure. Specifications don’t serve code—code serves specifications. The Product Requirements Document (PRD) isn’t a guide for implementation; it’s the source that generates implementation. Technical plans aren’t documents that inform coding; they’re precise definitions that produce code. This isn’t an incremental improvement to how we build software. It’s a fundamental rethinking of what drives development.&lt;/p&gt;
&lt;p&gt;The gap between specification and implementation has plagued software development since its inception. We’ve tried to bridge it with better documentation, more detailed requirements, stricter processes. These approaches fail because they accept the gap as inevitable. They try to narrow it but never eliminate it. SDD eliminates the gap by making specifications and their concrete implementation plans born from the specification executable. When specifications and implementation plans generate code, there is no gap—only transformation.&lt;/p&gt;
&lt;p&gt;This transformation is now possible because AI can understand and implement complex specifications, and create detailed implementation plans. But raw AI generation without structure produces chaos. SDD provides that structure through specifications and subsequent implementation plans that are precise, complete, and unambiguous enough to generate working systems. The specification becomes the primary artifact. Code becomes its expression (as an implementation from the implementation plan) in a particular language and framework.&lt;/p&gt;
&lt;p&gt;In this new world, maintaining software means evolving specifications. The intent of the development team is expressed in natural language (“&lt;strong&gt;intent-driven development&lt;/strong&gt;”), design assets, core principles and other guidelines. The &lt;strong&gt;lingua franca&lt;/strong&gt; of development moves to a higher level, and code is the last-mile approach.&lt;/p&gt;
&lt;p&gt;Debugging means fixing specifications and their implementation plans that generate incorrect code. Refactoring means restructuring for clarity. The entire development workflow reorganizes around specifications as the central source of truth, with implementation plans and code as the continuously regenerated output. Updating apps with new features or creating a new parallel implementation because we are creative beings, means revisiting the specification and creating new implementation plans. This process is therefore a 0 -&gt; 1, (1’, ..), 2, 3, N.&lt;/p&gt;
&lt;p&gt;The development team focuses in on their creativity, experimentation, their critical thinking.&lt;/p&gt;
&lt;h2 id=&quot;the-spec-kitty-philosophy-code-as-source-of-truth&quot;&gt;The Spec Kitty Philosophy: Code as Source of Truth&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;This is where Spec Kitty diverges from traditional spec-driven development.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;In Spec Kitty, &lt;strong&gt;CODE IS THE SOURCE OF TRUTH&lt;/strong&gt; - it represents what exists NOW. The specification is NOT a comprehensive digital twin of the codebase. Instead, specifications are &lt;strong&gt;CHANGE REQUESTS&lt;/strong&gt; that describe the DELTA between current reality and desired future state.&lt;/p&gt;
&lt;h3 id=&quot;why-this-matters&quot;&gt;Why This Matters&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;For LLMs working with Spec Kitty:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Always read the code&lt;/strong&gt; to understand current implementation&lt;/li&gt;
&lt;li&gt;The specification tells you WHAT TO CHANGE, not what currently exists&lt;/li&gt;
&lt;li&gt;Don’t assume the spec documents the entire system&lt;/li&gt;
&lt;li&gt;Code truth &gt; spec documentation&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;For developers:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Specs describe “we want to ADD authentication” not “the system includes authentication”&lt;/li&gt;
&lt;li&gt;Specs are forward-looking change requests, not backward-looking documentation&lt;/li&gt;
&lt;li&gt;Keep specs focused on the delta, not comprehensive system documentation&lt;/li&gt;
&lt;li&gt;After the Mission lands on its target branch, the code becomes the new truth; the spec is now historical context&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;the-philosophical-break-from-spec-kit&quot;&gt;The Philosophical Break from Spec Kit&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Traditional Spec-Driven Development (Spec Kit approach):&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Specification attempts to be comprehensive documentation&lt;/li&gt;
&lt;li&gt;Spec describes the entire system state&lt;/li&gt;
&lt;li&gt;Updates try to keep spec in sync with code&lt;/li&gt;
&lt;li&gt;Spec serves as system documentation&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;Spec Kitty Philosophy:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Code is always the definitive source of truth&lt;/li&gt;
&lt;li&gt;Specifications are change requests (deltas)&lt;/li&gt;
&lt;li&gt;LLMs read code to understand NOW, read specs to understand FUTURE&lt;/li&gt;
&lt;li&gt;Specs become historical record once the Mission lands (after consolidation), not living documentation&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;why-this-approach-works-better-for-ai-agents&quot;&gt;Why This Approach Works Better for AI Agents&lt;/h3&gt;
&lt;p&gt;AI agents have a superpower: &lt;strong&gt;they can read and understand code instantly&lt;/strong&gt;. Traditional specs tried to save humans from reading code by documenting everything. But LLMs don’t need that protection - they can read thousands of lines of code in seconds.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Benefits:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;✅ Specs stay focused and concise (describe only what changes)&lt;/li&gt;
&lt;li&gt;✅ No spec drift (specs don’t try to track current state)&lt;/li&gt;
&lt;li&gt;✅ LLMs always work from ground truth (the actual code)&lt;/li&gt;
&lt;li&gt;✅ Faster development (no comprehensive system documentation needed)&lt;/li&gt;
&lt;li&gt;✅ Specs accurately describe intent (the delta) not current state&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;Example:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Traditional approach (Spec Kit):&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;plaintext&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Specification: &quot;The system has user authentication with email/password,&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;session management, and password reset. It uses JWT tokens stored in&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;httpOnly cookies. The UserService handles authentication logic...&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;[... 500 lines documenting entire auth system ...]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;Spec Kitty approach:&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;plaintext&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Specification: &quot;Add OAuth2 social login (Google, GitHub) alongside&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;existing email/password authentication. Keep current JWT session&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;management unchanged.&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Implementation: LLM reads current auth code, understands JWT system,&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;adds OAuth2 providers as delta to existing system.&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;The difference:&lt;/strong&gt; Spec Kitty specs are concise change requests. LLMs read the codebase to understand context, then implement the specified delta.&lt;/p&gt;
&lt;h2 id=&quot;progress-tracking-with-kanban-lanes&quot;&gt;Progress Tracking with Kanban Lanes&lt;/h2&gt;
&lt;p&gt;Spec Kitty pairs specification rigor with a &lt;strong&gt;status-lane workflow&lt;/strong&gt; (the nine status lanes from &lt;code dir=&quot;auto&quot;&gt;planned&lt;/code&gt; to &lt;code dir=&quot;auto&quot;&gt;done&lt;/code&gt;, not the execution lanes of a topology) that keeps the entire team aligned. Every status lane transition is appended to the Mission’s status event log, giving product owners, reviewers, and AI assistants a single source of truth for progress. Agents coordinate through structured status commands (&lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks move-task&lt;/code&gt;), and &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks status&lt;/code&gt; highlights blockers, review requests, and idle work packages. This &lt;strong&gt;status board&lt;/strong&gt; becomes the heartbeat of the project—drive agent coordination from one place, rebalance workloads, and archive the full timeline for compliance.&lt;/p&gt;
&lt;h2 id=&quot;the-sdd-workflow-in-practice&quot;&gt;The SDD Workflow in Practice&lt;/h2&gt;
&lt;h3 id=&quot;interactive-discovery-comes-first&quot;&gt;Interactive Discovery Comes First&lt;/h3&gt;
&lt;p&gt;Spec Kitty treats specification and planning as co-creation activities. Every command starts with a mandatory interview that collects goals, users, constraints, quality bars, and risks before any documents are generated. The workflow pauses whenever answers are missing—no assumptions are made on your behalf without explicit confirmation.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Discovery Gates Enforce Completeness:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code dir=&quot;auto&quot;&gt;/spec-kitty.specify&lt;/code&gt; enters a discovery interview on first invocation, asking one question at a time and blocking with &lt;code dir=&quot;auto&quot;&gt;WAITING_FOR_DISCOVERY_INPUT&lt;/code&gt; until all answers are provided and an Intent Summary is confirmed&lt;/li&gt;
&lt;li&gt;&lt;code dir=&quot;auto&quot;&gt;/spec-kitty.plan&lt;/code&gt; follows the same pattern with &lt;code dir=&quot;auto&quot;&gt;WAITING_FOR_PLANNING_INPUT&lt;/code&gt;, interrogating tech stack, architecture, non-functional requirements, and operational constraints before generating artifacts&lt;/li&gt;
&lt;li&gt;Proportional depth: lightweight features receive lightweight questioning, while complex platform builds demand exhaustive interrogation&lt;/li&gt;
&lt;li&gt;No markdown tables rendered to users—agents track coverage internally and present one focused question per turn&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The workflow begins with an idea—often vague and incomplete. Through iterative dialogue with AI, this idea becomes a comprehensive PRD. The AI asks clarifying questions, identifies edge cases, and helps define precise acceptance criteria. What might take days of meetings and documentation in traditional development happens in hours of focused specification work. This transforms the traditional SDLC—requirements and design become continuous activities rather than discrete phases. This is supportive of a &lt;strong&gt;team process&lt;/strong&gt;, where team-reviewed specifications are expressed and versioned, created in branches, and integrated into the target branch through review.&lt;/p&gt;
&lt;p&gt;When a product manager updates acceptance criteria, implementation plans automatically flag affected technical decisions. When an architect discovers a better pattern, the PRD updates to reflect new possibilities.&lt;/p&gt;
&lt;p&gt;Throughout this specification process, research agents gather critical context. They investigate library compatibility, performance benchmarks, and security implications. Organizational constraints are discovered and applied automatically—your company’s database standards, authentication requirements, and deployment policies seamlessly integrate into every specification.&lt;/p&gt;
&lt;p&gt;From the PRD, AI generates implementation plans that map requirements to technical decisions. Every technology choice has documented rationale. Every architectural decision traces back to specific requirements. Throughout this process, consistency validation continuously improves quality. AI analyzes specifications for ambiguity, contradictions, and gaps—not as a one-time gate, but as an ongoing refinement.&lt;/p&gt;
&lt;p&gt;Code generation begins as soon as specifications and their implementation plans are stable enough, but they do not have to be “complete.” Early generations might be exploratory—testing whether the specification makes sense in practice. Domain concepts become data models. User stories become API endpoints. Acceptance scenarios become tests. This merges development and testing through specification—test scenarios aren’t written after code, they’re part of the specification that generates both implementation and tests.&lt;/p&gt;
&lt;p&gt;The feedback loop extends beyond initial development. Production metrics and incidents don’t just trigger hotfixes—they update specifications for the next regeneration. Performance bottlenecks become new non-functional requirements. Security vulnerabilities become constraints that affect all future generations. This iterative dance between specification, implementation, and operational reality is where true understanding emerges and where the traditional SDLC transforms into a continuous evolution.&lt;/p&gt;
&lt;h2 id=&quot;why-sdd-matters-now&quot;&gt;Why SDD Matters Now&lt;/h2&gt;
&lt;p&gt;Three trends make SDD not just possible but necessary:&lt;/p&gt;
&lt;p&gt;First, AI capabilities have reached a threshold where natural language specifications can reliably generate working code. This isn’t about replacing developers—it’s about amplifying their effectiveness by automating the mechanical translation from specification to implementation. It can amplify exploration and creativity, support “start-over” easily, and support addition, subtraction, and critical thinking.&lt;/p&gt;
&lt;p&gt;Second, software complexity continues to grow exponentially. Modern systems integrate dozens of services, frameworks, and dependencies. Keeping all these pieces aligned with original intent through manual processes becomes increasingly difficult. SDD provides systematic alignment through specification-driven generation. Frameworks may evolve to provide AI-first support, not human-first support, or architect around reusable components.&lt;/p&gt;
&lt;p&gt;Third, the pace of change accelerates. Requirements change far more rapidly today than ever before. Pivoting is no longer exceptional—it’s expected. Modern product development demands rapid iteration based on user feedback, market conditions, and competitive pressures. Traditional development treats these changes as disruptions. Each pivot requires manually propagating changes through documentation, design, and code. The result is either slow, careful updates that limit velocity, or fast, reckless changes that accumulate technical debt.&lt;/p&gt;
&lt;p&gt;SDD can support what-if/simulation experiments: “If we need to re-implement or change the application to promote a business need to sell more T-shirts, how would we implement and experiment for that?”&lt;/p&gt;
&lt;p&gt;SDD transforms requirement changes from obstacles into normal workflow. When specifications drive implementation, pivots become systematic regenerations rather than manual rewrites. Change a core requirement in the PRD, and affected implementation plans update automatically. Modify a user story, and corresponding API endpoints regenerate. This isn’t just about initial development—it’s about maintaining engineering velocity through inevitable changes.&lt;/p&gt;
&lt;h2 id=&quot;core-principles&quot;&gt;Core Principles&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Specifications as the Lingua Franca&lt;/strong&gt;: The specification becomes the primary artifact. Code becomes its expression in a particular language and framework. Maintaining software means evolving specifications.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Executable Specifications&lt;/strong&gt;: Specifications must be precise, complete, and unambiguous enough to generate working systems. This eliminates the gap between intent and implementation.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Continuous Refinement&lt;/strong&gt;: Consistency validation happens continuously, not as a one-time gate. AI analyzes specifications for ambiguity, contradictions, and gaps as an ongoing process.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Research-Driven Context&lt;/strong&gt;: Research agents gather critical context throughout the specification process, investigating technical options, performance implications, and organizational constraints.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Bidirectional Feedback&lt;/strong&gt;: Production reality informs specification evolution. Metrics, incidents, and operational learnings become inputs for specification refinement.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Branching for Exploration&lt;/strong&gt;: Generate multiple implementation approaches from the same specification to explore different optimization targets—performance, maintainability, user experience, cost.&lt;/p&gt;
&lt;h2 id=&quot;implementation-approaches&quot;&gt;Implementation Approaches&lt;/h2&gt;
&lt;p&gt;Today, practicing SDD requires assembling existing tools and maintaining discipline throughout the process. The methodology can be practiced with:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;AI assistants for iterative specification development&lt;/li&gt;
&lt;li&gt;Research agents for gathering technical context&lt;/li&gt;
&lt;li&gt;Code generation tools for translating specifications to implementation&lt;/li&gt;
&lt;li&gt;Version control systems adapted for specification-first workflows&lt;/li&gt;
&lt;li&gt;Consistency checking through AI analysis of specification documents&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The key is treating specifications as the source of truth, with code as the generated output that serves the specification rather than the other way around.&lt;/p&gt;
&lt;h2 id=&quot;streamlining-sdd-with-commands&quot;&gt;Streamlining SDD with Commands&lt;/h2&gt;
&lt;p&gt;The SDD methodology is significantly enhanced through three powerful commands that automate the specification → planning → tasking workflow:&lt;/p&gt;
&lt;h3 id=&quot;the-spec-kittyspecify-command&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.specify&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;This command turns a short description of a change (the user prompt) into a structured specification:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Discovery interview&lt;/strong&gt;: Asks one question at a time and ends each turn with &lt;code dir=&quot;auto&quot;&gt;WAITING_FOR_DISCOVERY_INPUT&lt;/code&gt; until the answers are complete and the Intent Summary is confirmed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Mission creation&lt;/strong&gt;: &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent mission create&lt;/code&gt; records the Mission’s identity in &lt;code dir=&quot;auto&quot;&gt;meta.json&lt;/code&gt;: a ULID &lt;code dir=&quot;auto&quot;&gt;mission_id&lt;/code&gt; and a &lt;code dir=&quot;auto&quot;&gt;mission_slug&lt;/code&gt; that ends with the first eight characters of that ULID (for example &lt;code dir=&quot;auto&quot;&gt;context-docs-refresh-01M7AN3N&lt;/code&gt;). A display &lt;code dir=&quot;auto&quot;&gt;mission_number&lt;/code&gt; is assigned only at consolidation.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Branch&lt;/strong&gt;: Without &lt;code dir=&quot;auto&quot;&gt;--topology&lt;/code&gt;, the Mission gets one topic branch (&lt;code dir=&quot;auto&quot;&gt;kitty/mission-&amp;#x3C;slug&gt;&lt;/code&gt;) and no worktree; the topology settles at the first &lt;code dir=&quot;auto&quot;&gt;finalize-tasks&lt;/code&gt;, by size.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Template-based generation&lt;/strong&gt;: Writes &lt;code dir=&quot;auto&quot;&gt;kitty-specs/&amp;#x3C;mission_slug&gt;/spec.md&lt;/code&gt; from the mission type’s spec template.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Planning commands run from the repository root checkout; no worktree is required for &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.specify&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.plan&lt;/code&gt; or &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.tasks&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&quot;the-spec-kittyplan-command&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.plan&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;Once a Mission specification exists, this command creates the implementation plan:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Planning interview&lt;/strong&gt;: Asks about tech stack, architecture, non-functional requirements and operational constraints, ending each turn with &lt;code dir=&quot;auto&quot;&gt;WAITING_FOR_PLANNING_INPUT&lt;/code&gt; until the answers are complete.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Charter Check&lt;/strong&gt;: Checks the plan against the gates the project charter defines.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Technical translation&lt;/strong&gt;: Converts the requirements into technical decisions, with a Complexity Tracking section for any gate it has to break.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Research&lt;/strong&gt;: Generates and extends &lt;code dir=&quot;auto&quot;&gt;research.md&lt;/code&gt; during Phase 0 (findings captured earlier through &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.research&lt;/code&gt; are extended, not replaced).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Design artifacts&lt;/strong&gt;: Generates &lt;code dir=&quot;auto&quot;&gt;data-model.md&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;contracts/&lt;/code&gt; and &lt;code dir=&quot;auto&quot;&gt;quickstart.md&lt;/code&gt; in Phase 1, where they apply.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&quot;the-spec-kittytasks-command&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.tasks&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;After the plan is complete, this command turns it into work packages in three steps (&lt;code dir=&quot;auto&quot;&gt;tasks-outline&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;tasks-packages&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;tasks-finalize&lt;/code&gt;):&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inputs&lt;/strong&gt;: Reads &lt;code dir=&quot;auto&quot;&gt;plan.md&lt;/code&gt; (required) and, where present, &lt;code dir=&quot;auto&quot;&gt;data-model.md&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;contracts/&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;research.md&lt;/code&gt; and &lt;code dir=&quot;auto&quot;&gt;quickstart.md&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Task derivation&lt;/strong&gt;: Converts contracts, entities and scenarios into subtasks (&lt;code dir=&quot;auto&quot;&gt;Txxx&lt;/code&gt;), marking safe parallel work with &lt;code dir=&quot;auto&quot;&gt;[P]&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Work package grouping&lt;/strong&gt;: Groups subtasks into work packages (&lt;code dir=&quot;auto&quot;&gt;WPxx&lt;/code&gt;): 3 to 7 subtasks each as a target, 10 at most.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Prompt generation&lt;/strong&gt;: Writes one prompt file per work package in the flat &lt;code dir=&quot;auto&quot;&gt;tasks/&lt;/code&gt; directory and links each from &lt;code dir=&quot;auto&quot;&gt;tasks.md&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Finalization&lt;/strong&gt;: &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent mission finalize-tasks&lt;/code&gt; validates dependencies, writes the lane metadata (&lt;code dir=&quot;auto&quot;&gt;lanes.json&lt;/code&gt;, execution lanes) and settles the topology. A work package’s status lives only in the Mission’s &lt;code dir=&quot;auto&quot;&gt;status.events.jsonl&lt;/code&gt;; frontmatter carries no &lt;code dir=&quot;auto&quot;&gt;lane&lt;/code&gt; field.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&quot;the-spec-kittyimplement-workflow&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.implement&lt;/code&gt; Workflow&lt;/h3&gt;
&lt;p&gt;&lt;code dir=&quot;auto&quot;&gt;spec-kitty agent action implement WPxx --agent &amp;#x3C;name&gt;&lt;/code&gt; is the only supported way to start a work package. It checks that every dependency is &lt;code dir=&quot;auto&quot;&gt;approved&lt;/code&gt; or &lt;code dir=&quot;auto&quot;&gt;done&lt;/code&gt;, moves the work package from &lt;code dir=&quot;auto&quot;&gt;planned&lt;/code&gt; through &lt;code dir=&quot;auto&quot;&gt;claimed&lt;/code&gt; to &lt;code dir=&quot;auto&quot;&gt;in_progress&lt;/code&gt; in the status event log (two events), prepares the workspace (the lane worktree &lt;code dir=&quot;auto&quot;&gt;.worktrees/&amp;#x3C;slug&gt;-lane-&amp;#x3C;id&gt;&lt;/code&gt; for a lanes topology, the write checkout for &lt;code dir=&quot;auto&quot;&gt;single_branch&lt;/code&gt;) and prints the prompt.&lt;/p&gt;
&lt;p&gt;While working, the agent:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Records notes in the status event log with &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks add-history WPxx --note &quot;...&quot;&lt;/code&gt;, without moving status lanes.&lt;/li&gt;
&lt;li&gt;Records subtask progress with &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks mark-status&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Checks progress with &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks status&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;When the work is done, the agent moves the work package to review with &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks move-task WPxx --to for_review&lt;/code&gt;. That move refuses while subtasks are unchecked, and on a code lane while the lane branch has no commits.&lt;/p&gt;
&lt;p&gt;The optional git hook &lt;code dir=&quot;auto&quot;&gt;scripts/git-hooks/pre-commit-task-workflow.sh&lt;/code&gt; refuses commits of &lt;code dir=&quot;auto&quot;&gt;kitty-specs/&lt;/code&gt; from an execution lane’s branch and validates staged task prompts.&lt;/p&gt;
&lt;h3 id=&quot;the-spec-kittyreview-command&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.review&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;&lt;code dir=&quot;auto&quot;&gt;spec-kitty agent action review WPxx --agent &amp;#x3C;name&gt;&lt;/code&gt; moves a work package from &lt;code dir=&quot;auto&quot;&gt;for_review&lt;/code&gt; to &lt;code dir=&quot;auto&quot;&gt;in_review&lt;/code&gt; and prints its prompt with any earlier review feedback. The reviewer then either approves (&lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks move-task WPxx --to approved&lt;/code&gt;) or rejects it back to &lt;code dir=&quot;auto&quot;&gt;planned&lt;/code&gt; with &lt;code dir=&quot;auto&quot;&gt;--review-feedback-file&lt;/code&gt;. Each move is recorded in &lt;code dir=&quot;auto&quot;&gt;status.events.jsonl&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&quot;the-spec-kittyaccept-command&quot;&gt;The &lt;code dir=&quot;auto&quot;&gt;/spec-kitty.accept&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;Use this command when every work package is &lt;code dir=&quot;auto&quot;&gt;approved&lt;/code&gt; or &lt;code dir=&quot;auto&quot;&gt;done&lt;/code&gt;. &lt;code dir=&quot;auto&quot;&gt;spec-kitty accept&lt;/code&gt; validates the Mission’s readiness, records the acceptance metadata in &lt;code dir=&quot;auto&quot;&gt;kitty-specs/&amp;#x3C;mission_slug&gt;/meta.json&lt;/code&gt; and, unless &lt;code dir=&quot;auto&quot;&gt;--no-commit&lt;/code&gt; is given, creates an acceptance commit. It takes &lt;code dir=&quot;auto&quot;&gt;--mode&lt;/code&gt; (&lt;code dir=&quot;auto&quot;&gt;auto&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;pr&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;local&lt;/code&gt; or &lt;code dir=&quot;auto&quot;&gt;checklist&lt;/code&gt;) and &lt;code dir=&quot;auto&quot;&gt;--json&lt;/code&gt;. After acceptance, &lt;code dir=&quot;auto&quot;&gt;spec-kitty consolidate&lt;/code&gt; does two local steps: &lt;a href=&quot;/context/orchestration/#lane-consolidation&quot;&gt;lane consolidation&lt;/a&gt; of the execution lane branches into the Mission branch, then &lt;a href=&quot;/context/orchestration/#branch-integration--git-merge&quot;&gt;branch integration&lt;/a&gt; of the Mission branch into the local target branch (a &lt;code dir=&quot;auto&quot;&gt;single_branch&lt;/code&gt; Mission has no lanes, so only the second step runs). &lt;a href=&quot;/context/orchestration/#publish-to-originmain&quot;&gt;Publishing to origin&lt;/a&gt; goes through a pull request.&lt;/p&gt;
&lt;p&gt;This discipline ensures:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Full traceability&lt;/strong&gt;: every status lane move is an event with its actor in &lt;code dir=&quot;auto&quot;&gt;status.events.jsonl&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No stalled work&lt;/strong&gt;: &lt;code dir=&quot;auto&quot;&gt;spec-kitty agent tasks status&lt;/code&gt; shows what is in progress, waiting for review or blocked&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Clear handoffs&lt;/strong&gt;: review gates run before a work package can be approved&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Parallel workflow visibility&lt;/strong&gt;: work packages in different execution lanes can run at the same time, each in its own lane worktree&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;example-building-a-chat-feature&quot;&gt;Example: Building a Chat Feature&lt;/h3&gt;
&lt;p&gt;Here’s how these commands transform the traditional development workflow:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Traditional Approach:&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;1. Write a PRD in a document (2-3 hours)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;2. Create design documents (2-3 hours)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;3. Set up project structure manually (30 minutes)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;4. Write technical specifications (3-4 hours)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;5. Create test plans (2 hours)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Total: ~12 hours of documentation work&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;SDD with Commands Approach:&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame is-terminal not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;span class=&quot;title&quot;&gt;&lt;/span&gt;&lt;span class=&quot;sr-only&quot;&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;bash&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# Step 1: Create the Mission specification (5 minutes)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82AAFF;--1:#3B61B0&quot;&gt;/spec-kitty.specify&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;Real-time&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;chat&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;system&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;with&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;message&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;history&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;and&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;user&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;presence&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# This automatically:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - Creates the Mission (slug such as chat-system-01ABCDEF) and its topic branch&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - Generates kitty-specs/chat-system-01ABCDEF/spec.md&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - Populates it with structured requirements&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# Step 2: Generate implementation plan (5 minutes)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82AAFF;--1:#3B61B0&quot;&gt;/spec-kitty.plan&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;WebSocket&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;for&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;real-time&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;messaging,&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;PostgreSQL&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;for&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;history,&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;Redis&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;for&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; &lt;/span&gt;&lt;span style=&quot;--0:#ECC48D;--1:#3B61B0&quot;&gt;presence&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# Step 3: Generate executable tasks (5 minutes)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82AAFF;--1:#3B61B0&quot;&gt;/spec-kitty.tasks&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# Steps 2 and 3 create:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/plan.md&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/research.md (WebSocket library comparisons)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/data-model.md (Message and User schemas)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/contracts/ (WebSocket events, REST endpoints)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/quickstart.md (Key validation scenarios)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/tasks.md (Work packages with subtasks)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#919F9F;--1:#5F636F&quot;&gt;# - kitty-specs/chat-system-01ABCDEF/tasks/WP0x-*.md (Prompt files in the flat tasks/ directory)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;In 15 minutes, you have:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A complete Mission specification with user stories and acceptance criteria&lt;/li&gt;
&lt;li&gt;A detailed implementation plan with technology choices and rationale&lt;/li&gt;
&lt;li&gt;API contracts and data models ready for code generation&lt;/li&gt;
&lt;li&gt;Comprehensive test scenarios for both automated and manual testing&lt;/li&gt;
&lt;li&gt;All documents properly versioned in a topic branch&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&quot;the-power-of-structured-automation&quot;&gt;The Power of Structured Automation&lt;/h3&gt;
&lt;p&gt;These commands don’t just save time—they enforce consistency and completeness:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;No Forgotten Details&lt;/strong&gt;: Templates ensure every aspect is considered, from non-functional requirements to error handling&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Traceable Decisions&lt;/strong&gt;: Every technical choice links back to specific requirements&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Living Documentation&lt;/strong&gt;: Specifications stay in sync with code because they generate it&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Rapid Iteration&lt;/strong&gt;: Change requirements and regenerate plans in minutes, not days&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;The commands embody SDD principles by treating specifications as executable artifacts rather than static documents. They transform the specification process from a necessary evil into the driving force of development.&lt;/p&gt;
&lt;h3 id=&quot;template-driven-quality-how-structure-constrains-llms-for-better-outcomes&quot;&gt;Template-Driven Quality: How Structure Constrains LLMs for Better Outcomes&lt;/h3&gt;
&lt;p&gt;The true power of these commands lies not just in automation, but in how the templates guide LLM behavior toward higher-quality specifications. The templates act as sophisticated prompts that constrain the LLM’s output in productive ways.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Where these quotes come from.&lt;/strong&gt; The snippets in this section follow GitHub Spec Kit’s templates. Spec Kitty’s built-in software-dev templates and step prompts (&lt;code dir=&quot;auto&quot;&gt;packs/built-in/missions/software-dev/templates/&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;packs/built-in/missions/mission-steps/software-dev/&lt;/code&gt;) carry some of the same rules: the WHAT-not-HOW guidance, the &lt;code dir=&quot;auto&quot;&gt;[NEEDS CLARIFICATION]&lt;/code&gt; markers and the requirement-completeness checklist in the specify prompt, and the Charter Check and Complexity Tracking sections in the plan template. They do not carry the Phase -1 Simplicity and Anti-Abstraction gates, the &lt;code dir=&quot;auto&quot;&gt;implementation-details/&lt;/code&gt; rule or the File Creation Order list; Spec Kitty’s plan template takes its gates from the project charter instead.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h4 id=&quot;1-preventing-premature-implementation-details&quot;&gt;1. &lt;strong&gt;Preventing Premature Implementation Details&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;The feature specification template explicitly instructs:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- ✅ Focus on WHAT users need and WHY&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- ❌ Avoid HOW to implement (no tech stack, APIs, code structure)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This constraint forces the LLM to maintain proper abstraction levels. When an LLM might naturally jump to “implement using React with Redux,” the template keeps it focused on “users need real-time updates of their data.” This separation ensures specifications remain stable even as implementation technologies change.&lt;/p&gt;
&lt;h4 id=&quot;2-forcing-explicit-uncertainty-markers&quot;&gt;2. &lt;strong&gt;Forcing Explicit Uncertainty Markers&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;Both templates mandate the use of &lt;code dir=&quot;auto&quot;&gt;[NEEDS CLARIFICATION]&lt;/code&gt; markers:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;When creating this spec from a user prompt:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;1. **Mark all ambiguities**: Use [NEEDS CLARIFICATION: specific question]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;2. **Don&apos;t guess**: If the prompt doesn&apos;t specify something, mark it&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This prevents the common LLM behavior of making plausible but potentially incorrect assumptions. Instead of guessing that a “login system” uses email/password authentication, the LLM must mark it as &lt;code dir=&quot;auto&quot;&gt;[NEEDS CLARIFICATION: auth method not specified - email/password, SSO, OAuth?]&lt;/code&gt;.&lt;/p&gt;
&lt;h4 id=&quot;3-structured-thinking-through-checklists&quot;&gt;3. &lt;strong&gt;Structured Thinking Through Checklists&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;The templates include comprehensive checklists that act as “unit tests” for the specification:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;markdown&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;### Requirement Completeness&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] No [NEEDS CLARIFICATION] markers remain&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Requirements are testable and unambiguous&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Success criteria are measurable&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;These checklists force the LLM to self-review its output systematically, catching gaps that might otherwise slip through. It’s like giving the LLM a quality assurance framework.&lt;/p&gt;
&lt;h4 id=&quot;4-charter-compliance-through-gates&quot;&gt;4. &lt;strong&gt;Charter Compliance Through Gates&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;The implementation plan template enforces architectural principles through phase gates:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;markdown&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;### Phase -1: Pre-Implementation Gates&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;#### Simplicity Gate (Article VII)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Using ≤3 projects?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] No future-proofing?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;#### Anti-Abstraction Gate (Article VIII)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Using framework directly?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Single model representation?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;These gates prevent over-engineering by making the LLM explicitly justify any complexity. If a gate fails, the LLM must document why in the “Complexity Tracking” section, creating accountability for architectural decisions.&lt;/p&gt;
&lt;h4 id=&quot;5-hierarchical-detail-management&quot;&gt;5. &lt;strong&gt;Hierarchical Detail Management&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;The templates enforce proper information architecture:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;**IMPORTANT**: This implementation plan should remain high-level and readable.&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Any code samples, detailed algorithms, or extensive technical specifications&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;must be placed in the appropriate `implementation-details/` file&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This prevents the common problem of specifications becoming unreadable code dumps. The LLM learns to maintain appropriate detail levels, extracting complexity to separate files while keeping the main document navigable.&lt;/p&gt;
&lt;h4 id=&quot;6-test-first-thinking&quot;&gt;6. &lt;strong&gt;Test-First Thinking&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;The implementation template enforces test-first development:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;### File Creation Order&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;1. Create `contracts/` with API specifications&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;2. Create test files in order: contract → integration → e2e → unit&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;3. Create source files to make tests pass&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This ordering constraint ensures the LLM thinks about testability and contracts before implementation, leading to more robust and verifiable specifications.&lt;/p&gt;
&lt;h4 id=&quot;7-preventing-speculative-features&quot;&gt;7. &lt;strong&gt;Preventing Speculative Features&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;Templates explicitly discourage speculation:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- [ ] No speculative or &quot;might need&quot; features&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- [ ] All phases have clear prerequisites and deliverables&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This stops the LLM from adding “nice to have” features that complicate implementation. Every feature must trace back to a concrete user story with clear acceptance criteria.&lt;/p&gt;
&lt;h3 id=&quot;the-compound-effect&quot;&gt;The Compound Effect&lt;/h3&gt;
&lt;p&gt;These constraints work together to produce specifications that are:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Complete&lt;/strong&gt;: Checklists ensure nothing is forgotten&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Unambiguous&lt;/strong&gt;: Forced clarification markers highlight uncertainties&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Testable&lt;/strong&gt;: Test-first thinking baked into the process&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Maintainable&lt;/strong&gt;: Proper abstraction levels and information hierarchy&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Implementable&lt;/strong&gt;: Clear phases with concrete deliverables&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The templates transform the LLM from a creative writer into a disciplined specification engineer, channeling its capabilities toward producing consistently high-quality, executable specifications that truly drive development.&lt;/p&gt;
&lt;h2 id=&quot;the-charter-foundation-enforcing-architectural-discipline&quot;&gt;The Charter Foundation: Enforcing Architectural Discipline&lt;/h2&gt;
&lt;p&gt;At the heart of SDD lies a charter—a set of principles that govern how specifications become code. The charter (&lt;code dir=&quot;auto&quot;&gt;.kittify/charter/charter.md&lt;/code&gt;) acts as the architectural DNA of the system, ensuring that every generated implementation maintains consistency, simplicity, and quality.&lt;/p&gt;
&lt;h3 id=&quot;the-core-articles-of-development&quot;&gt;The Core Articles of Development&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Example articles.&lt;/strong&gt; The articles below are the example constitution from GitHub Spec Kit. Spec Kitty does not ship them: each project writes its own charter through &lt;code dir=&quot;auto&quot;&gt;spec-kitty charter interview&lt;/code&gt; and &lt;code dir=&quot;auto&quot;&gt;spec-kitty charter generate&lt;/code&gt;. The built-in software-dev mission’s agent context names three of them (Library-First, CLI Interface, Test-First) as practices.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;The example charter defines several core articles that shape every aspect of the development process:&lt;/p&gt;
&lt;h4 id=&quot;article-i-library-first-principle&quot;&gt;Article I: Library-First Principle&lt;/h4&gt;
&lt;p&gt;Every feature must begin as a standalone library—no exceptions. This forces modular design from the start:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Every feature in Specify MUST begin its existence as a standalone library.&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;No feature shall be implemented directly within application code without&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;first being abstracted into a reusable library component.&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This principle ensures that specifications generate modular, reusable code rather than monolithic applications. When the LLM generates an implementation plan, it must structure features as libraries with clear boundaries and minimal dependencies.&lt;/p&gt;
&lt;h4 id=&quot;article-ii-cli-interface-mandate&quot;&gt;Article II: CLI Interface Mandate&lt;/h4&gt;
&lt;p&gt;Every library must expose its functionality through a command-line interface:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;All CLI interfaces MUST:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Accept text as input (via stdin, arguments, or files)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Produce text as output (via stdout)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Support JSON format for structured data exchange&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This enforces observability and testability. The LLM cannot hide functionality inside opaque classes—everything must be accessible and verifiable through text-based interfaces.&lt;/p&gt;
&lt;h4 id=&quot;article-iii-test-first-imperative&quot;&gt;Article III: Test-First Imperative&lt;/h4&gt;
&lt;p&gt;The most transformative article—no code before tests:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;This is NON-NEGOTIABLE: All implementation MUST follow strict Test-Driven Development.&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;No implementation code shall be written before:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;1. Unit tests are written&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;2. Tests are validated and approved by the user&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;3. Tests are confirmed to FAIL (Red phase)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This completely inverts traditional AI code generation. Instead of generating code and hoping it works, the LLM must first generate comprehensive tests that define behavior, get them approved, and only then generate implementation.&lt;/p&gt;
&lt;h4 id=&quot;articles-vii--viii-simplicity-and-anti-abstraction&quot;&gt;Articles VII &amp;#x26; VIII: Simplicity and Anti-Abstraction&lt;/h4&gt;
&lt;p&gt;These paired articles combat over-engineering:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Section 7.3: Minimal Project Structure&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Maximum 3 projects for initial implementation&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Additional projects require documented justification&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Section 8.1: Framework Trust&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Use framework features directly rather than wrapping them&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;When an LLM might naturally create elaborate abstractions, these articles force it to justify every layer of complexity. The implementation plan template’s “Phase -1 Gates” directly enforce these principles.&lt;/p&gt;
&lt;h4 id=&quot;article-ix-integration-first-testing&quot;&gt;Article IX: Integration-First Testing&lt;/h4&gt;
&lt;p&gt;Prioritizes real-world testing over isolated unit tests:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Tests MUST use realistic environments:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Prefer real databases over mocks&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Use actual service instances over stubs&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Contract tests mandatory before implementation&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This ensures generated code works in practice, not just in theory.&lt;/p&gt;
&lt;h3 id=&quot;charter-enforcement-through-templates&quot;&gt;Charter Enforcement Through Templates&lt;/h3&gt;
&lt;p&gt;The implementation plan template operationalizes these articles through concrete checkpoints:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;markdown&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;### Phase -1: Pre-Implementation Gates&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;#### Simplicity Gate (Article VII)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Using ≤3 projects?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] No future-proofing?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;#### Anti-Abstraction Gate (Article VIII)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Using framework directly?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Single model representation?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#82B1FF;--1:#3B61B0&quot;&gt;#### Integration-First Gate (Article IX)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Contracts defined?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#D9F5DD;--1:#111111&quot;&gt;-&lt;/span&gt;&lt;span style=&quot;--0:#D6DEEB;--1:#403F53&quot;&gt; [ ] Contract tests written?&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;These gates act as compile-time checks for architectural principles. The LLM cannot proceed without either passing the gates or documenting justified exceptions in the “Complexity Tracking” section.&lt;/p&gt;
&lt;h3 id=&quot;the-power-of-immutable-principles&quot;&gt;The Power of Immutable Principles&lt;/h3&gt;
&lt;p&gt;The charter’s power lies in its immutability. While implementation details can evolve, the core principles remain constant. This provides:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Consistency Across Time&lt;/strong&gt;: Code generated today follows the same principles as code generated next year&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Consistency Across LLMs&lt;/strong&gt;: Different AI models produce architecturally compatible code&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Architectural Integrity&lt;/strong&gt;: Every feature reinforces rather than undermines the system design&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Quality Guarantees&lt;/strong&gt;: Test-first, library-first, and simplicity principles ensure maintainable code&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&quot;charter-evolution&quot;&gt;Charter Evolution&lt;/h3&gt;
&lt;p&gt;While principles are immutable, their application can evolve:&lt;/p&gt;
&lt;div class=&quot;expressive-code&quot;&gt;&lt;figure class=&quot;frame not-content&quot;&gt;&lt;figcaption class=&quot;header&quot;&gt;&lt;/figcaption&gt;&lt;pre data-language=&quot;text&quot;&gt;&lt;code&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Section 4.2: Amendment Process&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;Modifications to this charter require:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Explicit documentation of the rationale for change&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Review and approval by project maintainers&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div class=&quot;ec-line&quot;&gt;&lt;div class=&quot;code&quot;&gt;&lt;span style=&quot;--0:#d6deeb;--1:#403f53&quot;&gt;- Backwards compatibility assessment&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;This allows the methodology to learn and improve while maintaining stability. The charter shows its own evolution with dated amendments, demonstrating how principles can be refined based on real-world experience.&lt;/p&gt;
&lt;h3 id=&quot;beyond-rules-a-development-philosophy&quot;&gt;Beyond Rules: A Development Philosophy&lt;/h3&gt;
&lt;p&gt;The charter isn’t just a rulebook—it’s a philosophy that shapes how LLMs think about code generation:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Observability Over Opacity&lt;/strong&gt;: Everything must be inspectable through CLI interfaces&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Simplicity Over Cleverness&lt;/strong&gt;: Start simple, add complexity only when proven necessary&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Integration Over Isolation&lt;/strong&gt;: Test in real environments, not artificial ones&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Modularity Over Monoliths&lt;/strong&gt;: Every feature is a library with clear boundaries&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;By embedding these principles into the specification and planning process, SDD ensures that generated code isn’t just functional—it’s maintainable, testable, and architecturally sound. The charter transforms AI from a code generator into an architectural partner that respects and reinforces system design principles.&lt;/p&gt;
&lt;h2 id=&quot;the-transformation&quot;&gt;The Transformation&lt;/h2&gt;
&lt;p&gt;This isn’t about replacing developers or automating creativity. It’s about amplifying human capability by automating mechanical translation. It’s about creating a tight feedback loop where specifications, research, and code evolve together, each iteration bringing deeper understanding and better alignment between intent and implementation.&lt;/p&gt;
&lt;p&gt;Software development needs better tools for maintaining alignment between intent and implementation. SDD provides the methodology for achieving this alignment through executable specifications that generate code rather than merely guiding it.&lt;/p&gt;
&lt;h2 id=&quot;glossary-requirement-identifiers&quot;&gt;Glossary: requirement identifiers&lt;/h2&gt;
&lt;h3 id=&quot;requirement-id&quot;&gt;Requirement ID&lt;/h3&gt;

































&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Definition&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;A stable identifier for one spec requirement: a kind (&lt;code dir=&quot;auto&quot;&gt;FR&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;NFR&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;C&lt;/code&gt;, or &lt;code dir=&quot;auto&quot;&gt;SC&lt;/code&gt;; a research Mission also accepts &lt;code dir=&quot;auto&quot;&gt;DR&lt;/code&gt;, &lt;code dir=&quot;auto&quot;&gt;AR&lt;/code&gt; and &lt;code dir=&quot;auto&quot;&gt;QR&lt;/code&gt;), a digit string whose width is significant, an optional single lowercase letter suffix, and an optional &lt;code dir=&quot;auto&quot;&gt;&amp;#x3C;mission-slug&gt;#&lt;/code&gt; qualifier; canonical form is kind uppercase, digits verbatim, suffix lowercase.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Context&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;Spec-Driven Development&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Status&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;canonical&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Applicable to&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;code dir=&quot;auto&quot;&gt;3.x&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Do NOT use when&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;The identifier is an implementation-concern ID (&lt;code dir=&quot;auto&quot;&gt;IC-##&lt;/code&gt;, a separate plan-level grammar; see the linked ADR below), or a work package ID.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Related terms&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;a href=&quot;#success-criterion&quot;&gt;Success criterion&lt;/a&gt;, &lt;a href=&quot;#qualified-citation&quot;&gt;Qualified citation&lt;/a&gt;, &lt;a href=&quot;/context/orchestration/#work-package&quot;&gt;work package&lt;/a&gt;, &lt;a href=&quot;/context/orchestration/#mission&quot;&gt;Mission&lt;/a&gt;, the single-grammar-authority ADR (&lt;code dir=&quot;auto&quot;&gt;../adr/3.x/2026-09-29-1-requirement-id-grammar-single-authority.md&lt;/code&gt;)&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;hr&gt;
&lt;h3 id=&quot;success-criterion&quot;&gt;Success criterion&lt;/h3&gt;

































&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Definition&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;A measurable outcome a spec declares with the &lt;code dir=&quot;auto&quot;&gt;SC&lt;/code&gt; kind. It is a Requirement ID that is tracked (reported in finalize-tasks’ informational success-criteria coverage) but not gating: an undeclared &lt;code dir=&quot;auto&quot;&gt;SC&lt;/code&gt; ref cited on a work package still fails as &lt;code dir=&quot;auto&quot;&gt;unknown_spec_id&lt;/code&gt;.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Context&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;Spec-Driven Development&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Status&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;canonical&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Applicable to&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;code dir=&quot;auto&quot;&gt;3.x&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Do NOT use when&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;The concept is an acceptance scenario of a user story, or a functional requirement whose mapping is coverage-gated.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Related terms&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;a href=&quot;#requirement-id&quot;&gt;Requirement ID&lt;/a&gt;, &lt;a href=&quot;#qualified-citation&quot;&gt;Qualified citation&lt;/a&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;hr&gt;
&lt;h3 id=&quot;qualified-citation&quot;&gt;Qualified citation&lt;/h3&gt;

































&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Definition&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;A Requirement ID prefixed with another mission’s slug and &lt;code dir=&quot;auto&quot;&gt;#&lt;/code&gt; (&lt;code dir=&quot;auto&quot;&gt;&amp;#x3C;mission-slug&gt;#FR-###&lt;/code&gt;). It belongs to the named mission, is never declared, required, flagged, or warned about, and is reported as &lt;code dir=&quot;auto&quot;&gt;foreign_qualified&lt;/code&gt; (never failing) when cited in a work package’s refs; the qualifier itself is never resolved.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Context&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;Spec-Driven Development&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Status&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;canonical&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Applicable to&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;code dir=&quot;auto&quot;&gt;3.x&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Do NOT use when&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;Citing a GitHub issue reference (&lt;code dir=&quot;auto&quot;&gt;#&lt;/code&gt; plus digits) or a file path.&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Related terms&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;a href=&quot;#requirement-id&quot;&gt;Requirement ID&lt;/a&gt;, &lt;a href=&quot;#success-criterion&quot;&gt;Success criterion&lt;/a&gt;, the single-grammar-authority ADR (&lt;code dir=&quot;auto&quot;&gt;../adr/3.x/2026-09-29-1-requirement-id-grammar-single-authority.md&lt;/code&gt;)&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;</content>
</entry>
