Intent Contract Template
intent-contract-template.md
Replaces spec-template.md
Restructures specs around outcomes, constraints, scenarios, proof targets, plus runtime artifact version fields.
DownloadINTENT + GitHub Spec Kit
INTENT + GitHub Spec Kit
A complete operating model for AI-native development and runtime governance.
INTENT v0.5 provides organizational governance and runtime safety boundaries while GitHub Spec Kit provides engineering workflow automation. Together they answer the full system question: who decides, what evidence is required, how much agent freedom is allowed, and how live behavior stays auditable.
The Three-Layer Model
INTENT composes with Spec Kit instead of competing with it. The BUILD and VALIDATE phases of INTENT run through Spec Kit, while governance above and tooling below stay explicitly separated and runtime artifacts remain enforceable.
Selected layer details
INTENT Framework
- - Team structure and roles: Systems Conductor, Intent Architect, Proof Steward.
- - Ceremonies and governance: Direction Check, Proof Review, risk classification, and autonomy policy.
- - Constitution plus runtime governance artifacts (Trust Envelope, Escalation Contract, Interaction State Model) for live systems.
INTENT links directly to Constitution, Proof Tier, Autonomy Tier, Intent Contract, and Scenario Bank, Runtime Governance, Trust Envelope, Escalation Contract, and Interaction State Model definitions on the main framework page.
INTENT composes with Spec Kit rather than competing. The BUILD and VALIDATE phases execute through Spec Kit workflows while governance remains explicit and tool choice stays portable.
Phase Mapping
Click a row to expand implementation notes for each phase handoff, including runtime-governance validation.
| INTENT Phase | Spec Kit Command | What Happens | Who Does It |
|---|---|---|---|
| specify init | Install Spec Kit CLI and scaffold .specify/ directory. | Developer (once per project) | |
| /speckit.constitution | Write non-negotiable principles; becomes INTENT's Constitution artifact. | Systems Conductor drafts, team reviews | |
| /speckit.specify | Define outcomes, constraints, and scenarios; becomes an Intent Contract. | Intent Architect provides intent, agent structures | |
| Replace generic user stories with outcome-centric contract framing and proof targets. | |||
| /speckit.clarify | Agent asks for ambiguity resolution and humans answer. | Intent Architect answers | |
| (manual or prompted) | Create Scenario Bank holdout validation set. | Intent Architect writes or prompts agent | |
| (manual or prompted) | Author runtime artifacts for live agent surfaces. | Systems Conductor + Intent Architect | |
| /speckit.plan | Generate technical plan, data model, and API contracts. | Agent generates, Intent Architect reviews | |
| /speckit.tasks | Break plan into ordered, dependency-aware tasks. | Agent generates, human performs quick scan | |
| /speckit.implement | Agent executes tasks, writes code, runs tests. | Agent implements at assigned autonomy tier | |
| (CI + manual) | Run Scenario Bank and check drift against Constitution. | Proof Steward verifies evidence | |
| (runtime checks) | Verify trust-envelope compliance and escalation/state-path behavior. | Proof Steward + runtime owner | |
| (git + CI/CD) | PR with Proof Report; deploy through standard pipeline. | Standard team workflow | |
| (monitoring) | Production signals update Scenario Bank and feed the next FRAME cycle. | Closed loop: team + automated signals | |
What INTENT Adds to Spec Kit
| Dimension | Spec Kit Alone | Spec Kit + INTENT |
|---|---|---|
| Governance | Constitution defines technical constraints | Constitution also defines risk classification, proof requirements, autonomy policy, and amendment process |
| Specification | User stories and acceptance criteria | Intent Contracts with outcomes, constraints, scenarios, proof targets, and risk tiers |
| Validation | Tests pass | Scenario Bank plus runtime governance checks that verify intent-level outcomes and runtime behavior |
| Human role | Implicit intervention decisions | Explicit autonomy policy with trust ladder and intervention rules |
| Drift detection | Not explicitly addressed | Build-time, runtime, and spec drift detection |
| Runtime safety boundary | Prompt-level guardrails are implicit | Explicit Trust Envelope, Escalation Contract, and Interaction State Model artifacts |
| Escalation behavior | Ad hoc fallback behavior | Versioned escalation classes, precedence rules, and fallback protocols |
| Feedback loop | Pipeline often ends at implement | LEARN phase feeds production evidence into the next cycle |
| Team structure | Not defined | Systems Conductor, Intent Architect, Proof Steward |
The INTENT Template Pack for Spec Kit
Drop these files into .specify/templates/ to replace default templates with INTENT v0.5 aligned versions, including runtime-governance artifacts.
Constitution Starter
constitution-starter.md
Adds risk classification, proof thresholds, autonomy policy, and runtime-governance trigger requirements.
DownloadScenario Bank Schema
scenarios-template.yaml
Defines holdout scenarios with preconditions, steps, outcomes, signals, and runtime state/escalation mapping.
DownloadEnhanced Plan Template
plan-template-intent.md
Replaces plan-template.md
Extends plan generation with governance context, runtime validation checkpoints, and contribution mapping.
DownloadEnhanced Tasks Template
tasks-template-intent.md
Replaces tasks-template.md
Adds per-task proof requirements, scenario mapping, human gates, and runtime-governance proof report scaffolding.
DownloadTrust Envelope Template
trust-envelope-template.md
Defines authorized runtime output categories, confidence levels, violation severity, and detection methods.
DownloadEscalation Contract Template
escalation-contract-template.md
Defines escalation classes, protocol steps, timeouts, fallback paths, and evidence capture.
DownloadInteraction State Model Template
interaction-state-model-template.md
Defines interaction states, transition rules, state-level permissions, and scenario state-path mapping.
DownloadGet Started in 10 Minutes
Step 1: Install Spec Kit ------------------------ $ uv tool install specify-cli --from git+https://github.com/github/spec-kit.git Step 2: Initialize in your project ----------------------------------- $ cd your-project $ specify init . --ai claude --force Step 3: Replace templates with INTENT versions ----------------------------------------------- Copy files into .specify/templates/: - intent-contract-template.md -> replaces spec-template.md - constitution-starter.md -> reference for /speckit.constitution - scenarios-template.yaml -> new artifact - plan-template-intent.md -> replaces plan-template.md - tasks-template-intent.md -> replaces tasks-template.md - trust-envelope-template.md -> new runtime artifact - escalation-contract-template.md -> new runtime artifact - interaction-state-model-template.md -> new runtime artifact Step 4: Write your Constitution ------------------------------- claude> /speckit.constitution [principles + risk/proof/autonomy policy] Step 5: Build your first feature -------------------------------- claude> /speckit.specify [outcomes, constraints, scenarios] claude> /speckit.clarify claude> Create scenarios.yaml from the Intent Contract scenarios claude> Create trust-envelope.md from trust-envelope-template.md (for live agent surfaces) claude> Create escalation-contract.md from escalation-contract-template.md (for live agent surfaces) claude> Create interaction-state-model.md from interaction-state-model-template.md (for live agent surfaces) claude> /speckit.plan [your stack] claude> /speckit.tasks claude> /speckit.implement Step 6: Validate against the Scenario Bank ------------------------------------------ Walk each scenario in scenarios.yaml. Check drift against the Constitution. Verify trust-envelope compliance and escalation/state-path behavior. Write the Proof Report. Ship it.
File Structure
your-project/ ├── .specify/ │ ├── memory/ │ │ └── constitution.md <- INTENT Constitution │ ├── specs/ │ │ └── 001-feature-name/ │ │ ├── intent-contract.md <- Intent Contract │ │ ├── scenarios.yaml <- Scenario Bank │ │ ├── trust-envelope.md <- Runtime governance artifact │ │ ├── escalation-contract.md <- Runtime governance artifact │ │ ├── interaction-state-model.md <- Runtime governance artifact │ │ ├── plan.md <- Enhanced plan │ │ ├── tasks.md <- Enhanced tasks │ │ ├── research.md │ │ └── contracts/ │ │ └── api-spec.json │ ├── scripts/ │ └── templates/ │ ├── intent-contract-template.md │ ├── constitution-starter.md │ ├── plan-template-intent.md │ ├── tasks-template-intent.md │ ├── scenarios-template.yaml │ ├── trust-envelope-template.md │ ├── escalation-contract-template.md │ └── interaction-state-model-template.md ├── CLAUDE.md └── src/
Where INTENT Sits on the Spec Continuum
| Proof Tier | Spec Role | What It Means |
|---|---|---|
| P0-P1 | Spec-first | Specs guide agents. Code is the source of truth and specs remain documentation. |
| P2-P3 | Spec-anchored | Specs constrain agents. Specs and code co-evolve while drift detection catches divergence. |
| P4 | Spec-as-source | Specs govern agents. Code is generated output and may become disposable. |
Most teams start at P1 and grow toward P2. These templates are optimized for that P1 to P2 journey.
Ready to govern your AI-native workflow?
GitHub Spec Kit is an open-source project by GitHub (MIT license). INTENT is not affiliated with GitHub. The INTENT Template Pack is a community contribution that customizes Spec Kit templates for use with the INTENT Framework.