Extensions

Assign specialized Claude Code agents to spec-kit tasks for targeted execution

A structured 7-step workflow for building new projects from scratch with AI assistants — from vision through implementation.

Predicts architectural impact, complexity, and risks of proposed changes before implementation.

Archive merged features into main project memory, resolving gaps and conflicts.

Sync user stories and tasks to Azure DevOps work items using OAuth authentication.

Stay code-literate in AI-driven development: review a complete code blueprint for every task from spec artifacts before /speckit.implement runs

Configurable branch and folder naming conventions for /specify with presets and custom patterns.

Bootstrap spec-kit for existing codebases — auto-discover architecture and adopt SDD incrementally.

Structured bugfix workflow — capture bugs, trace to spec artifacts, and patch specs surgically.

Adds canon-driven (baseline-driven) workflows: spec-first, code-first, spec-drift. Requires Canon Core preset installation.

Automated validation for spec-kit community catalog entries — structure, URLs, diffs, and linting.

An extension to commit the changes made during the middle of the implementation, so you don't end up with just one very large commit at the end.

Spec compliance gates for CI/CD — verify specs exist, check drift, and block merges on gaps.

Post-implementation quality gate that reviews changes, fixes small issues (scout rule), creates tasks for medium issues, and generates analysis for large issues.

Executes a single spec-kit phase via sub-agent delegation to reduce context pollution.

Create, read, and update Confluence docs for your project

Canonical-Driven Development enforcement. Validates, scores, and traces project documentation with automated checks, AI-driven workflows, and spec-kit hooks. Zero NPM runtime dependencies.

Create and validate extensions and extension catalogs.

Automated analyze-fix-reanalyze loop that resolves spec findings until clean.

Spec-aware bug fixing: maps bugs to spec artifacts, proposes a plan, applies minimal changes.

Orchestrate a full feature lifecycle with human-in-the-loop gates across all SpecKit phases.

Generate spec artifacts from GitHub Issues - import issues, sync updates, and maintain bidirectional traceability

Creates and syncs local specs based on an existing issue in GitHub

Iterate on spec documents with a two-phase define-and-apply workflow — refine specs mid-implementation and go straight back to building

Create Jira Epics, Stories, and Issues from spec-kit specifications and task breakdowns with configurable hierarchy and custom field support.

Generate educational guides from implementations and enhance clarifications with mentoring context.

Coordinator → feature → QA agent workflow with parallel worktree-based implementation. Language-agnostic. Auto-detects installed board plugins (Trello, Linear, GitHub Projects, Jira, Azure DevOps). Optional CI gate.

Azure DevOps Boards integration for the MAQA extension. Populates work items from specs, moves User Stories across columns as features progress, real-time Task child ticking.

CI/CD pipeline gate for the MAQA extension. Auto-detects GitHub Actions, CircleCI, GitLab CI, and Bitbucket Pipelines. Blocks QA handoff until pipeline is green.

GitHub Projects v2 integration for the MAQA extension. Populates draft issues from specs, moves items across Status columns as features progress, real-time task list ticking.

Jira integration for the MAQA extension. Populates Stories from specs, moves issues across board columns as features progress, real-time Subtask ticking.

Linear integration for the MAQA extension. Populates issues from specs, moves items across workflow states as features progress, real-time sub-issue ticking.

Trello board integration for the MAQA extension. Populates board from specs, moves cards between lists as features progress, real-time checklist ticking.

Loads .specify/memory/ files before spec-kit lifecycle commands so LLM agents have project governance context

Repository-native durable memory for Spec Kit projects

Agent memory governance tool: Automatically audits and fixes boundary conflicts between AGENTS.md and the constitution.

Contextual onboarding and progressive growth for developers new to spec-kit projects. Explains specs, maps dependencies, validates understanding, and guides the next step.

Audits and optimizes AI governance for context efficiency

Require spec.md and plan.md to be merged via MR/PR before allowing task generation

Auto-generate pull request descriptions, checklists, and summaries from spec artifacts.

Create and validate presets and preset catalogs.

Full product lifecycle from research to release — portfolio, lite mode, monorepo, optional V-Model

Diagnose a Spec Kit project and report health issues across structure, agents, features, scripts, extensions, and git.

Show current SDD workflow progress — active feature, artifact status, task completion, workflow phase, and extensions summary.

Systematic QA testing with browser-driven or CLI-based validation of acceptance criteria from spec.

Autonomous implementation loop using AI agent CLI.

Reconcile implementation drift by surgically updating the feature's own spec, plan, and tasks.

Adversarial review of functional specs before /speckit.plan. Parallel adversarial lens agents catch hostile actors, silent failures, and regulatory blind spots that clarify/analyze cannot.

Generate index of your repo for overview, architecture and module

Sprint retrospective analysis with metrics, spec accuracy assessment, and improvement suggestions.

Post-implementation retrospective with spec adherence scoring, drift analysis, and human-gated spec updates.

Post-implementation comprehensive code review with specialized agents for code quality, comments, tests, error handling, type design, and simplification.

Detect side effects that tests can't catch after implementation — delta-anchored analysis across 9 domain-agnostic categories with fix-induced side effect detection

Resume interrupted workflows, validate project health, and verify spec-to-task traceability.

Comprehensive security audit of codebases using AI-powered DevSecOps analysis

Enterprise-Grade Spec-Driven Development (SDD) Framework for Salesforce.

Automates release pipeline: pre-flight checks, branch sync, changelog generation, CI verification, and PR creation.

Dual-lens critical review of spec and plan from product strategy and engineering risk perspectives.

Auto-generate Mermaid diagrams of SDD workflow state, feature progress, and task dependencies.

Cross-feature orchestration — track state, select tasks, and detect conflicts across parallel specs.

Reads the ## References section from the current feature spec and loads the listed files into context

Update specs in-place, propagate changes to plan and tasks, and diff impact across artifacts.

Effort estimation and scope tracking — estimate work, detect creep, and budget time per phase.

Detect and resolve drift between specs and implementation. AI-assisted resolution with human approval.

Comprehension validation, review gating, and approval state for spec-kit artifacts — staged-reveal quizzes, peer review SLA, and a hard gate before /speckit.implement.

Auto-generate test scaffolds from spec criteria, map coverage, and find untested requirements.

Staff-engineer-level code review that validates implementation against spec, checks security, performance, and test coverage.

Project status, feature progress, and next-action recommendations for spec-driven workflows.

Orchestrates obra/superpowers skills within the spec-kit SDD workflow. Thin bridge commands delegate to superpowers' authoritative SKILL.md files at runtime (with graceful fallback), while bridge-original commands provide spec-kit-native value. Eight commands cover the full lifecycle: intent clarification, TDD enforcement, task review, verification, critique, systematic debugging, branch completion, and review response. Hook-bound commands fire automatically; standalone commands are invoked when needed.

Bridges spec-kit workflows with obra/superpowers capabilities for brainstorming, TDD, code review, and resumable execution.

Lightweight single-file workflow for small tasks — skip the heavy multi-step SDD process.

Enforces V-Model paired generation of development specs and test specs with full traceability.

Post-implementation quality gate that validates implemented code against specification artifacts.

Detect phantom completions: tasks marked [X] in tasks.md with no real implementation.

Verify tech stack versions against live registries before planning and implementation

Preview the downstream impact (complexity, effort, tasks, risks) of requirement changes before committing to them.

SVG wireframe generation, review, and sign-off for spec-driven development. Approved wireframes become spec constraints honored by /speckit.plan, /speckit.tasks, and /speckit.implement.

Spawn isolated git worktrees for parallel feature development without checkout switching.

Default-on worktree isolation for parallel agents — sibling or nested layout