SpecBind

SpecBind keeps durable software specifications bound to agent-assisted delivery, from intent through release.

AI coding agents can implement quickly, but the reasoning around a change is easy to lose: requirements become one-off prompts, design decisions drift away from the code, and a later agent has to reconstruct what the product is supposed to do. SpecBind gives that reasoning a maintained home and makes it part of the delivery lifecycle.

What SpecBind does

SpecBind combines agent skills with a deterministic CLI:

• Skills own judgment. Agents help discover the right scope, author requirements and designs, review contracts, plan tasks, implement changes, and evaluate results.
• The CLI owns invariants. It validates artifacts and traceability, records approvals and task progress, detects stale downstream work, and guards lifecycle and release transitions.
• Specs stay alive. A Spec describes a product capability across milestones and releases. Later changes update the same durable requirements, design, and external contract instead of starting from a disposable plan.
• Existing products can establish a baseline. Evidence-backed reverse discovery can establish durable Specs from a fixed implementation revision without presenting existing behavior as a new release.
• Milestones make delivery explicit. A Roadmap groups the work intended for a release, including dependencies across Specs and smaller Direct changes that do not need their own Spec.
• Contracts expose cross-Spec seams early. A contract-first review happens before task planning, so ownership conflicts, dependency cycles, and integration assumptions surface before implementation.

SpecBind is not a gate on every repository edit. Work enters the workflow when it belongs to a tracked delivery, changes behavior or boundaries owned by a Spec, or creates a new durable responsibility. Unrelated maintenance can remain ordinary work.

The lifecycle

The deliberate path is:

discover scope
  -> requirements
  -> design and contract
  -> contract review
  -> tasks
  -> implementation and verification
  -> release

Approvals bind each phase to the exact inputs that were reviewed. If an upstream artifact changes, SpecBind marks the affected downstream evidence stale rather than letting an agent silently continue from an obsolete plan. Faster orchestration can reuse the same artifacts and guards without defining a weaker workflow.

Projects can adapt document templates, shared rules, and Git, release, or final-validation guidance while keeping the product's validation and state transitions consistent. SpecBind is developed and tested with Codex and Claude Code, and provides shared Agent Skills and AGENTS.md integration for other compatible agents. English and Japanese are the v1 artifact languages.

Get started

Install the CLI

The latest stable release supports Windows x64, Linux x64, and macOS ARM64. The latest stable release can be installed without choosing a version.

With mise, on any supported platform:

mise use github:Huruikagi/specbind
mise lock

This installs the latest stable version eligible under your mise settings and records it in the mise configuration selected for the current directory. mise applies a minimum release age to latest by default. If a newly published stable release is not eligible yet, select that version explicitly with github:Huruikagi/specbind@<version>. mise lock records the selected version and distribution checksum so the project can use the same release consistently.

Without mise, use the platform installer.

Windows PowerShell:

irm https://raw.githubusercontent.com/Huruikagi/specbind/main/install.ps1 | iex

WSL2/Linux or Apple Silicon macOS:

curl -fsSL https://raw.githubusercontent.com/Huruikagi/specbind/main/install.sh | sh

Both installers verify the release archive against SHA256SUMS, install to the platform default, and leave persistent PATH changes to the user. Use -InstallDir on PowerShell or --install-dir on Linux/macOS to choose another location.

Confirm the installed version:

specbind --version

Install SpecBind into a project

From the root of a Git repository with at least one commit, install the Codex integration and English artifact defaults:

specbind install --agent codex --language en --project-instructions

Use claude-code instead of codex for Claude Code, or generic for another host that supports Agent Skills and AGENTS.md. Repeat --agent to install more than one integration, and use ja instead of en for Japanese artifacts. The command installs the product-managed Skills and creates project-owned templates, rules, and adapter guidance under .specbind/settings/.

Then choose the route that matches the repository:

• Start a new project before application implementation has begun.
• Start with an existing project when code or tests already exist.

Choose a route explains both routes and their prerequisites, and Install SpecBind covers the installation step they share. The Japanese guide covers the same workflow under ルートを選ぶ.

Review and commit the installed files, then reopen the coding-agent session so it discovers the new Skills. Codex invokes them as $sb-*; Claude Code uses /sb-*. Follow the selected route into sb-discovery, then use sb-plan and sb-drive to advance the active milestone. Use sb-configure whenever the project defaults or integration need review.

Learn more

• Documentation site is the published entry point for the user guide and current reference pages.
• English user guide and Japanese user guide cover installation, delivery, customization, updating, and removal.
• Generated skill index and generated artifact index are concise snapshots of the current interface.

Design and development references

• Target workflows describes the intended user journeys and responsibility boundaries.
• Target artifact catalog explains which records persist and who owns them.
• CLI and agent boundary explains why judgment belongs to agents while deterministic operations belong to the CLI.
• Repository map indexes the source layout, design documents, and decision record.

Repository layout

• tools/specbind/ — canonical Rust workspace for the specbind executable
• tools/cc-sdd/ — inherited TypeScript migration oracle
• docs/design/ — target workflows, lifecycle models, and accepted design decisions

Development

The workspace uses Rust 1.98.0, Rustfmt, and Clippy for development through rust-toolchain.toml, while Cargo.toml retains Rust 1.97.1 as the minimum supported Rust version. Install Rustup before running Cargo commands. Windows development with the default MSVC target also requires Visual Studio Build Tools with the Desktop development with C++ workload and a Windows SDK.

Run the current CLI from the Rust workspace:

cd tools/specbind
cargo run -- --help

Run the complete Rust verification set before committing Rust changes:

cargo fmt --all -- --check
cargo run --example generate_schemas -- --check
cargo clippy --workspace --all-targets --all-features -- -D warnings
cargo test --workspace --all-features
cargo build --workspace --release

Cargo.lock is committed because SpecBind distributes an application binary. The ordinary Rust workflow runs these checks on Linux. The release workflow repeats them while building the supported native archives on Windows, Linux, and macOS.

The versioned Rust DTOs under src/schema/ are the structural source of truth for structured artifacts. After changing them, regenerate the checked-in Draft 2020-12 schemas and review the resulting diff:

cargo run --example generate_schemas

Embedded skills also have behavioral verification that cannot run in CI. Build its fixture project and follow the forward-test procedure:

sh tools/specbind/scripts/forward-test-fixture.sh /tmp/specbind-fixture en

The inherited TypeScript oracle retains its own verification commands:

cd tools/cc-sdd
npm test
npm run build

Language support

SpecBind v1 officially supports English (en) and Japanese (ja). Other languages are not currently part of the supported product contract.

Upstream and attribution

SpecBind began from the source code of cc-sdd by gotalab, which itself inherited from Kiro. We are grateful to Kiro, the original project, and their contributors for the foundation.

SpecBind is an independent project and is not affiliated with or endorsed by gotalab. The original copyright and MIT license notice are retained in LICENSE.

License

MIT License. See LICENSE.