DOCSEARCHbyAlgolia
Submit Docs

SpecifyPlus: Spec-Driven Development Toolkit

repository·main·Indexed 42 days ago

https://github.com/panaversity/spec-kit-plus

An enhanced Spec-Driven Development (SDD) toolkit for building scalable, multi-agent AI systems. It combines structured specifications with 'vibe coding' to provide architectural coherence and production-ready scaffolds using the OpenAI Agents SDK, MCP, and cloud-native runtimes. The toolkit includes the specify-cli (v0.0.20.post1) to bootstrap projects and provides prompt templates for architects, TDD, and Architecture Decision Records (ADRs).

Tokens
177.3K
Snippets
363
Records
601
Agent score
52%

What's inside SpecifyPlus

  1. Overview of Claude Code AI CLI

    main

    Claude Code is a professional-grade AI CLI tool designed for terminal-based development. It supports advanced agentic workflows including the use of subagents, plugins, and custom skills. It can be extended using the Model Context Protocol (MCP) to connect to external tools and data sources, and supports headless mode for automation.

    Key capabilities include:

    • Subagents: Delegating tasks to specialized sub-processes.
    • Plugins & Skills: Extending functionality through orchestration and automation.
    • Hooks: Automating workflows to reduce manual supervision.
    • MCP Integration: Connecting Claude Code to various tools via MCP servers.
    • Headless Mode: Running the CLI without a TTY for CI/CD or automated environments.

  2. What is Spec-Kit Plus?

    main

    Spec-Kit Plus is a toolkit for orchestrating vertical agentic solutions by transforming natural language specifications into production-ready multi-agent AI systems. It follows a spec-driven development philosophy where the user focuses on system design and domain expertise, while AI handles implementation, testing, deployment, and maintenance.

    Key enhancements over the original spec-kit include:

    • Multi-Agent Support: Integration with OpenAI Agents SDK, Swarm patterns, and Agent-to-Agent (A2A) protocols.
    • MCP Integration: Support for 200+ connectors and custom MCP server templates.
    • Cloud-Native Deployment: Templates for Docker, Kubernetes, Dapr, and Ray.
    • Vertical Solution Templates: Starters for Finance, Healthcare, Legal, and Education.
    • Reusable Intelligence: A library of subagent templates and skill definitions.

  3. Overview of Spec-Kit-Plus

    main

    Spec-Kit-Plus is an enhanced Spec-Driven Development toolkit designed for building scalable, multi-agent AI systems. It enables "Spec-driven Vibe-coding" by combining rapid, conversational generation with architectural coherence.

    Key capabilities include:

    • Providing patterns and templates for building vertical agentic solutions.
    • Supporting the OpenAI Agents SDK, Model Context Protocol (MCP), and Agent-to-Agent (A2A) protocols.
    • Integrating with cloud-native stacks such as Docker, Kubernetes, Dapr (Actors & Workflows), and Ray.
    • Helping developers transition from manual coding to specification engineering and system architecture.

  4. Overview of OpenAI ChatGPT-5 Codex

    main

    Codex is an OpenAI coding agent capable of reading entire repositories, modifying files, running code in sandboxes, and performing tasks in parallel. It is designed to work with the OpenAI Agents SDK patterns (tools, sessions, handoffs).

    Codex can be accessed through three primary surfaces:

    • Codex Cloud: Best for parallel, long-running, or repo-wide changes (e.g., generating tests/docs). Used within ChatGPT by assigning tasks.
    • Codex CLI: Best for local, repo-scoped edits with fast feedback. Installed in your terminal.
    • IDE Extension: Best for interactive editing, previewing diffs, and applying multi-file changes directly in your editor.

    You can hand work off between the Cloud (ChatGPT) and your local environment seamlessly.

  5. Compare Terminal-Based AI Assistants

    main

    Terminal-based AI assistants integrate LLMs directly into your command line to assist with code generation, bash/git command execution, debugging, and documentation. Choose a tool based on your budget and specific use case:

    • Gemini CLI (Gemini 2.5 Pro): Best for specification writing, PRD drafting, and complex reasoning. It offers a generous free tier and excellent shell script generation.
    • Qwen Code (Qwen 3 Coder): Best for budget-conscious coding. It is free, can run locally (offline), and provides very fast inference.
    • Claude Code (Claude Sonnet 4.5): Best for professional coding. It offers the highest code quality, largest context window, and superior debugging/system automation, but requires a $20/month subscription.
    | Feature | Gemini CLI | Qwen Code | Claude Code |
|---------|------------|-----------|-------------|
| **Cost** | Free (generous) | Free (local) | $20/month |
| **Quality** | Excellent | Very Good | Best |
| **Speed** | Fast | Very Fast | Fast |
| **Context** | Large | Medium | Very Large |
| **Best For** | Specs, PRDs, Debugging | Coding (free) | Professional Coding |
| **Offline** | No | Yes | No |
| **Model** | Gemini 2.5 Pro | Qwen 3 Coder | Claude Sonnet 4.5 |
| **Bash/Git Help** | Excellent | Very Good | Excellent |

  6. Understand the Evaluations Track structure

    main

    The track is organized into discrete steps, each focusing on a specific evaluation methodology:

    StepFocus Area
    01_baseline_trace/Minimal Agents SDK call using Gemini (OpenAI-compatible)
    02_objective_reflection_sql/Skeleton for objective reflection evaluations
    03_subjective_rubric_llm_judge/Skeleton for rubric-based subjective evaluations
    04_error_analysis/Skeleton for trace-anchored error analysis
    05_component_eval_search_quality/Preferred-domains ratio evaluation
    06_cost_latency_benchmark/Skeleton for timing and cost capture
    07_ab_harness/Skeleton for prompt/model A/B testing
    shared/Tiny helper utilities used across all steps

    Technical Notes:

    • Provider: Uses Gemini via an OpenAI-compatible API (configured in shared/config.py).
    • Observability: Supports optional Langfuse/OTEL integration. If LANGFUSE_* environment variables are present, traces can be exported.
    • CI/CD Integration: Step 05 is designed to exit with a non-zero status code on failure, allowing CI pipelines to gate on regressions.

  7. What is constitution.md and how to use it?

    main

    A constitution.md file defines non-negotiable, organization-wide engineering standards. While AGENTS.md provides project-specific instructions, constitution.md acts as the "law of the land" for all projects within an organization.

    It should cover several key domains:

    • Technology Standards: Approved stacks (languages, frameworks, databases).
    • Security Requirements: Authentication, data protection, and API security.
    • Code Quality Standards: Linting, formatting, and naming conventions.
    • Testing Requirements: Coverage targets and test types.
    • Documentation Standards: Required files and documentation depth.
    • Review & Deployment: Processes for code reviews and production releases.

  8. What is Spec-Driven Development (SDD)?

    main

    Spec-Driven Development (SDD) is a methodology designed for building software with AI agents. It inverts the traditional code-first paradigm by treating specifications as the central, authoritative source of truth. Instead of using vague prompts (often called "vibe coding"), SDD uses specifications as executable contracts that drive the entire engineering process, ensuring architectural consistency and reducing context loss in AI agents.

    Key Benefits:

    • Precision: Detailed specifications lead to consistent, maintainable code.
    • Auditability: Creates a structured, traceable development process.
    • Context Management: Provides persistent, explicit documentation to prevent AI agents from "forgetting" architectural decisions.

  9. What is Specification-Driven Development (SDD)?

    main

    Specification-Driven Development (SDD) is a methodology that inverts the traditional software development power structure. Instead of code being the source of truth and specifications serving as mere scaffolding, SDD makes specifications the primary artifact.

    In this model:

    • Specifications drive implementation: The Product Requirements Document (PRD) and technical plans are the sources that generate code, rather than just guiding it.
    • Code is an expression: Code is viewed as the 'last-mile' implementation of a specification in a specific language or framework.
    • Maintenance is specification evolution: Debugging, refactoring, and adding features are achieved by updating the specifications and implementation plans, which then trigger the regeneration of the code.
    • Intent-driven development: The development focus shifts to high-level intent, design assets, and core principles, using natural language as the primary medium of development.

  10. What is Model Context Protocol (MCP)?

    main

    The Model Context Protocol (MCP) is a standard for connecting AI models to external data sources and tools. It allows Claude Code to interact with the following abstractions:

    • Resources: Read-only data such as files, API responses, or database records.
    • Tools: Executable actions like creating tickets, sending messages, or updating databases.
    • Prompts: Reusable prompt templates provided by the server.

    Commonly used MCP servers include Google Drive, Slack, Jira/Linear, Figma, Notion, PostgreSQL, and GitHub.

  11. What is AGENTS.md and how to use it

    main

    An AGENTS.md file is a machine-readable specification designed for AI agents, serving a similar purpose to README.md for humans. While a README.md explains how humans use a project, an AGENTS.md explains how an AI agent should interact with, understand, and modify the project.

    To provide an agent with the necessary context for autonomous or semi-autonomous work, an AGENTS.md should include:

    • Project Overview & Structure: High-level purpose and directory organization.
    • Setup & Build Commands: Exact CLI commands for environment setup, building, and running.
    • Development Workflow: Instructions for branching, making changes, testing, and committing.
    • Code Style & Conventions: Specific linting, formatting, and naming rules (e.g., PascalCase for classes).
    • Architecture Notes: Mental models of the system (e.g., Clean Architecture, State Management).
    • Testing Strategy: How to run unit, integration, and E2E tests.
    • Permissions & Safety: A critical section defining what an agent is allowed to do autonomously (e.g., running linters) versus what requires explicit human approval (e.g., deploying to production or modifying .env files).
    # AGENTS.md

## Project Overview
[Description]

## Project Structure
[Organization]

## Setup Instructions
[Commands]

## Permissions and Safety
[Rules for the agent]

  12. What is Spec-Driven Development?

    main

    Spec-Driven Development (SDD) is a methodology that flips traditional development by making specifications executable. Instead of specifications being discarded scaffolding for manual coding, they serve as the primary driver that directly generates working implementations.

    Key principles include:

    • Intent-driven development: Defining the what before the how.
    • Rich specification creation: Using guardrails and organizational principles to build robust specs.
    • Multi-step refinement: Moving away from one-shot prompt-to-code generation in favor of iterative refinement.
    • AI-centricity: Leveraging advanced AI models to interpret and execute specifications.