Skip to main content
subagent CX Codex

speckit.constitution — Claude Code subagent: how it works & setup

speckit.constitution is a Claude Code subagent that creates and updates the project constitution at .specify/memory/constitution.md based on team principles.

MIT ★ 110 updated 2026-10-19

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓
.github/agents/speckit.constitution.agent.md
Open on GitHub

What speckit.constitution does

This subagent manages the project governance document located at .specify/memory/constitution.md. It executes .specify/scripts/bash/resolve-template.sh constitution-template --json to assemble the template scaffold across presets and layers. If that resolution script fails, execution halts immediately rather than falling back to an incomplete template.

A built-in scope guard prevents this agent from editing code, modifying test suites, or running builds. Any incoming feature tasks get classified as deferred intents and placed into a Next Actions summary with a suggestion to continue in speckit.specify.

Before modifying principles, the agent inspects .specify/extensions.yml for execution hooks. It increments the document semantic version based on changes and prepends an amendment report as an HTML comment.

What it helps with

  • Establish project governance standards and non-negotiable rules
  • Update .specify/memory/constitution.md following semantic versioning rules
  • Separate governance updates from implementation requests cleanly
  • Trigger pre-execution hooks before modifying team principles

Example prompts for the agent

  • Update the project constitution to require integration tests for all API handlers
  • Initialize .specify/memory/constitution.md from the resolved project template
  • Amend our governance document with stricter backward-compatibility rules

How to install speckit.constitution

Manually: put the files in place

.github/agents/speckit.constitution.agent.md

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about speckit.constitution

How to install speckit.constitution in Claude Code?

Add the agent specification file to your repository at .claude/agents/speckit.constitution.md.

What does speckit.constitution do?

It applies user principles to .specify/memory/constitution.md, calculates the new semver value, and generates a sync impact report.

Can speckit.constitution edit source code directly?

No, its scope guard blocks modifications to application code or tests, deferring coding requests to commands like /speckit.specify.

Source text

speckit.constitution.agent.md · MIT
---
description: Create or update the project constitution from interactive or provided principle inputs.
handoffs:
  - label: Build Specification
    agent: speckit.specify
    prompt: Implement the feature specification based on the updated constitution. I want to build...
---

## User Input

```text
$ARGUMENTS
```

You **MUST** consider the user input before proceeding (if not empty).

## Scope Guard

This command's own work is limited to updating the project constitution itself. Dependent templates
and commands read the constitution at runtime and are not modified here.

- Classify every part of the user input as either constitution content or a separate,
  non-governance intent.
- If the input includes feature implementation, code generation, refactoring, building, or
  deployment requests, you **MUST NOT** execute them. Extract them as deferred intents instead.
- You **MUST NOT** create, modify, or delete application source files, feature routes,
  components, tests, deployment files, or other artifacts unrelated to the constitution
  workflow.
- If it is unclear whether an instruction is constitution content, ask for clarification before
  making changes.
- After completing the constitution update, include a `Next Actions` section for each deferred
  intent. List the original intent and suggest the appropriate follow-up Spec Kit command, such
  as `/speckit.specify`, without invoking it.
- If there are no non-governance intents, omit the `Next Actions` section.

## Pre-Execution Checks

**Check for extension hooks (before constitution update)**:
- Check if `.specify/extensions.yml` exists in the project root.
- If it exists, read it and look for entries under the `hooks.before_constitution` key
- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
- For each executable hook, output the following based on its `optional` flag:
  - **Optional hook** (`optional: true`):
    ```
    ## Extension Hooks

    **Optional Pre-Hook**: {extension}
    Command: `/{command}`
    Description: {description}

    Prompt: {prompt}
    To execute: `/{command}`
    ```
  - **Mandatory hook** (`optional: false`):
    ```
    ## Extension Hooks

    **Automatic Pre-Hook**: {extension}
    Executing: `/{command}`
    EXECUTE_COMMAND: {command}

    Wait for the result of the hook command before proceeding to the Outline.
    ```
    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently

## Outline

You are updating the project constitution at `.specify/memory/constitution.md`. The active
constitution scaffold is resolved at command time from `constitution-template` through the Spec Kit
preset/template resolution stack.

Follow this execution flow:

1. Run `.specify/scripts/bash/resolve-template.sh constitution-template --json` from the repository root and parse `TEMPLATE_CONTENT` as the active template.
   - The shared resolver applies project overrides, composing preset layers, and extension layers
     before the core template fallback. It MUST succeed before continuing.
   - If it fails, stop and report the resolution error; do not continue with only one contributing
     template layer.
   - If `.specify/memory/constitution.md` exists, load it as the source of current project-specific
     values and amendments. Preserve information that is still applicable when applying the newly
     resolved scaffold.
   - If it does not exist, use the resolved template as the initial document.
   - Do not write back to any versioned template layer.
   - Identify every placeholder token of the form `[ALL_CAPS_IDENTIFIER]`.
   **IMPORTANT**: The user might require less or more principles than the ones used in the template. If a number is specified, respect that - follow the general template. You will update the doc accordingly.

2. Collect/derive values for placeholders:
   - If user input (conversation) supplies a value, use it.
   - Otherwise infer from existing repo context (README, docs, prior constitution versions if embedded).
   - For governance dates: `RATIFICATION_DATE` is the original adoption date (if unknown ask or mark TODO), `LAST_AMENDED_DATE` is today if changes are made, otherwise keep previous.
   - `CONSTITUTION_VERSION` must increment according to semantic versioning rules:
     - MAJOR: Backward incompatible governance/principle removals or redefinitions.
     - MINOR: New principle/section added or materially expanded guidance.
     - PATCH: Clarifications, wording, typo fixes, non-semantic refinements.
   - If version bump type ambiguous, propose reasoning before finalizing.

3. Draft the updated constitution content using the resolved template as the required structure:
   - Replace every placeholder with concrete text (no bracketed tokens left except intentionally retained template slots that the project has chosen not to define yet—explicitly justify any left).
   - Preserve heading hierarchy and comments can be removed once replaced unless they still add clarifying guidance.
   - Ensure each Principle section: succinct name line, paragraph (or bullet list) capturing non‑negotiable rules, explicit rationale if not obvious.
   - Ensure Governance section lists amendment procedure, versioning policy, and compliance review expectations.

4. Produce a Sync Impact Report as an HTML comment at the top of the constitution file after update.
   This report is temporary scratch material for human review of the amendment, not governance
   content; it is expected to be removed before the amended constitution file is committed.
   - Version change: old → new
   - List of modified principles (old title → new title if renamed)
   - Added sections
   - Removed sections
   - Follow-up TODOs if any placeholders intentionally deferred.

5. Validation before final output:
   - No remaining unexplained bracket tokens.
   - Version line matches report.
   - Dates ISO format YYYY-MM-DD.
   - Principles are declarative, testable, and free of vague language ("should" → replace with MUST/SHOULD rationale where appropriate).

6. Write the completed constitution back to `.specify/memory/constitution.md` (overwrite).

7. Output a final summary to the user with:
   - New version and bump rationale.
   - Any TODO placeholders or deferred items requiring manual follow-up.
   - Suggested commit message (e.g., `docs: amend constitution to vX.Y.Z (principle additions + governance update)`).
   - A `Next Actions` section for any deferred non-governance intents.

Formatting & Style Requirements:

- Use Markdown headings exactly as in the template (do not demote/promote levels).
- Wrap long rationale lines to keep readability (<100 chars ideally) but do not hard enforce with awkward breaks.
- Keep a single blank line between sections.
- Avoid trailing whitespace.

If the user supplies partial updates (e.g., only one principle revision), still perform validation and version decision steps.

If critical info missing (e.g., ratification date truly unknown), insert `TODO(<FIELD_NAME>): explanation` and include in the Sync Impact Report under deferred items.

Write only `.specify/memory/constitution.md`; do not create or modify template source files.

## Post-Execution Checks

**Check for extension hooks (after constitution update)**:
Check if `.specify/extensions.yml` exists in the project root.
- If it exists, read it and look for entries under the `hooks.after_constitution` key
- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
- For each executable hook, output the following based on its `optional` flag:
  - **Optional hook** (`optional: true`):
    ```
    ## Extension Hooks

    **Optional Hook**: {extension}
    Command: `/{command}`
    Description: {description}

    Prompt: {prompt}
    To execute: `/{command}`
    ```
  - **Mandatory hook** (`optional: false`):
    ```
    ## Extension Hooks

    **Automatic Hook**: {extension}
    Executing: `/{command}`
    EXECUTE_COMMAND: {command}
    ```
    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently

© alfredoperez · MIT · alfredoperez/speckit-companion

Similar subagents

All subagents for Agent setup: memory, context, orchestration →

From the same set83

The whole set →
speckit.taskstoissues speckit.taskstoissues turns the task list from tasks.md into numbered GitHub issues while keeping dependency order. Handy when the plan is already broken into tasks but the tracker is empty. CX Codex +1 ★ 110repo stars submit-catalog-update submit-catalog-update is a Claude Code skill that generates and files an Extension Submission issue for the companion extension in spec-kit. It is used for minor and major version updates. CX Codex +1 ★ 110repo stars feature-clip feature-clip builds SpecKit Companion looping clips through capture, composition, rendering, and media sync for the site and documentation. CX Codex +1 ★ 110repo stars publish-speckit-ext publish-speckit-ext — a command to publish the spec-kit extension to a GitHub release. Lets other developers install the extension via catalog without cloning the repository. CX Codex +1 ★ 110repo stars ship-ticket The ship-ticket command takes an implemented ticket from branch review through PR creation and merge. Use it when the code is already built in SpecKit Companion. CX Codex +1 ★ 110repo stars speckit.tasks speckit.tasks turns a feature into tasks.md: reads plan.md and spec.md from the feature folder and lays out the work per user story with dependencies. CX Codex +1 ★ 110repo stars speckit.clarify speckit.clarify pins down underspecified details in your feature spec with up to five targeted questions, saving choices directly to disk. CX Codex GP ChatGPT ★ 110repo stars speckit.analyze The speckit.analyze subagent checks spec.md, plan.md, and tasks.md for gaps and conflicts. Run it after task generation, before implementation. CX Codex +1 ★ 110repo stars

Project sponsors

Companies that keep this analytics open