Shift from Prompts to Specs for AI Coding

This methodology aims to move beyond the limitations of prompt-first AI coding, focusing on structured specifications.

The workflow integrates GitHub Enterprise, GitHub Copilot, and Spekit, creating a cohesive environment for developing robust and reproducible software.

Prompts are typically private, temporary, and lack clear review mechanisms, making them a weak foundation for enterprise-level development.

This approach can result in code that deviates from project requirements due to a lack of shared understanding and traceability.

This shift ensures that the core documentation of a project is persistent, reviewable, and version-controlled.

By making specifications the main artifact, teams can achieve greater consistency and maintainability, crucial for large-scale and long-term software development.

The Constitution defines the foundational, unbreakable enterprise rules, often broader than a single project or team, such as security standards and architectural principles.

The Spec phase describes the functional requirements of the application, focusing on 'what' it should do without delving into technical implementation details. This includes high-level user stories and desired behaviors.

The Plan phase translates these functional requirements into technical specifications, outlining the technology stack, deployment targets, and detailed architectural choices. Finally, the Task phase breaks down the project into smaller, manageable, and logical chunks, ready for implementation.

Every document, including the constitution, spec, and plan, must undergo thorough human scrutiny.

This comprehensive auditing ensures quality, validates adherence to project requirements, and fosters team alignment, preventing misunderstandings or errors from propagating through the development cycle.

A core principle of Spec-Driven Development is making specifications persistent artifacts within the Git repository. By integrating specs into the repository's history, they become version-controlled and traceable, just like code.

This ensures that every new feature implementation or project iteration can start from a well-defined, historically documented base, promoting a repeatable and consistent development process.

To begin, developers must install SpecIt and its Specify CLI tool. The process starts by opening a terminal and executing the 'specify init' command.

During initialization, users select their preferred AI integration tool, with GitHub Copilot being a common choice, and configure shell preferences, such as PowerShell for Windows environments.

This folder contains the framework's files, which are primarily based on markdown and scripting, not complex proprietary formats.

Developers are encouraged to explore this folder to understand its simple structure, removing any 'magic' assumptions and reinforcing that the framework is built on accessible, transparent technologies.

These rules include being 'grounded only,' meaning no hallucinated sessions, and 'time aware,' which is crucial for scheduling functions.

Further principles emphasize agent safety, HTTP safety, testability by design, and privacy by default. These constitutional rules ensure that all AI-generated code and components comply with strict enterprise and project standards.

These are the must-have rules that govern the entire development process, ensuring that the AI operates within predefined boundaries and aligns with critical business and technical requirements.

To integrate the defined constitution, the 'spec constitution' command is used, followed by pasting the prompt containing the constitutional principles. This command initiates the AI's processing of these rules.

The AI then integrates these principles into a 'memory' folder, creating a consistent markdown reference. This ensures that the AI's subsequent actions and code generation are always guided by the established foundational rules.

Functional requirements include aspects like data modeling and the integration of Model Context Protocol (MCP) tools. The emphasis here is on clearly articulating desired behaviors and features without detailing the technical implementation.

This means that any generated specifications, such as user stories for session search or detail retrieval, are inherently aligned with the defined 'must-haves' and principles.

The AI actively modifies and adapts its output to adhere to these core constitutional requirements, preventing deviations from the project's foundational rules.

This stage bridges the gap between functional specifications and concrete implementation.

It includes specifying the technology stack, such as TypeScript, Node.js, and the Model Context Protocol (MCP), along with the use of HTTP transport. Furthermore, this phase covers critical deployment and configuration settings, outlining how the application will be built and deployed.

This detailed technical plan ensures that developers have a clear blueprint for constructing the software according to the defined requirements and constraints.

When defining the technical plan, the AI may automatically fill in missing dependency versions. While convenient, users should be mindful of these auto-filled versions.

It is crucial to explicitly state desired versions if specific ones are required for the project, as the AI's defaults may not always align with the absolute latest releases or specific project needs.

After the plan phase, the '/spekit tasks' command is used to decompose user stories and technical plans into smaller, manageable units. This command efficiently chunks up all the defined requirements and plans.

These small units are designed to be easily executed and integrated by AI, streamlining the development process. The task creation synthesizes the constitution, functional requirements, and technical plans, ensuring a coherent workflow.

This breakdown facilitates efficient AI processing, allowing for modular development and better traceability of work items back to the original specifications.

This command takes the structured tasks and generates the corresponding application logic.

Crucially, it enforces a test-driven design approach, meaning that tests are generated alongside the code. These tests verify compilation and ensure that the generated functionality meets the specified requirements before the development task is considered complete.

This inspector allows for direct interaction with the server.

The demonstration successfully confirms tool discovery and session execution, showcasing that the generated code is indeed functional and adheres to the specified requirements. This step validates the entire development pipeline, from constitution to working code.

First, always write a comprehensive specification that captures 'what' and 'why' before writing any prompts, prioritizing understanding over immediate implementation.

Second, establish a 'living constitution' by defining two to five non-negotiable team rules within it. This document should be regularly reviewed and updated to reflect evolving project standards.

Third, rigorous review of all AI-generated output is paramount. Teams must carefully scrutinize every document and piece of code produced by the AI before it is integrated, ensuring quality and adherence to specifications.