Skip to content
renzrollonPublic

About

Spec-driven development for Claude Code, layered on OpenSpec. You read one spec; parallel agents ship it to a tested commit.

Topics

Resources

Code of conduct

Contributing

Security policy

Accessibility

Stars

62 stars

Watchers

0 watching

Forks

Interlock

Read one spec. Parallel agents ship it to a tested commit. One more command settles the pull request.

Spec-driven development for Claude Code, on OpenSpec.

npm downloads CI Claude Code ≥ 2.1.154 MIT Site

One real run, 34 seconds: /interlock:spec asks one question, writes the change and stops at the checkpoint; /interlock:ship runs two waves of parallel agents, the suite passes 180 of 180, one commit.

One real run, cut to 34 s: spec stops at the checkpoint, then ship runs two waves of parallel agents to one commit. Uncut, 2:34.

12 tasks · 2 waves · 19 agents · 13m 54s · 57 files · 2,881 lines · 180 of 180 pass · 1 commit

/interlock:spec "<idea>"   # explores your repo, writes a reviewed spec, then stops
                           # ← you read it. The only required stop.
/interlock:ship            # parallel agents → your tests pass → one commit. Asks nothing.

/interlock:settle          # draft PR → review → fix → re-review → verdict
                           # ← you press merge. Interlock never does.
  • One human checkpoint. A spec is the cheapest place to catch a wrong idea, so it is the one place you must look.
  • Nobody is asked mid-run. ship is a Claude Code workflow, and the runtime has no channel for a question.
  • Rules are code, not prose. Caps, gates and the merge verdict are CLI exit codes a model cannot argue with.

Install

In Claude Code, once per machine:

/plugin marketplace add renzrollon/interlock
/plugin install interlock@interlock

Then, in a new session in your project, once per repo:

/interlock:bootstrap

It writes one spec per existing feature and builds the graph agents navigate by. It never changes source code.

Nothing else to install. OpenSpec is provisioned on first use: a pinned copy from npm, checked against a lockfile the plugin carries, install scripts and telemetry off.

You need Claude Code 2.1.154+ with dynamic workflows on, Node.js 22.12+ with npm, and a git repository with code in it. Every session opens with interlock preflight OK or a list of fixes. Step by step: 01 — The first hour.

Why Interlock

Prompts are suggestions. Exit codes are not.

Other spec tools compete on how much structure you write before coding. Interlock competes on how many decisions the model is not allowed to make.

  • It cannot ask you anything. ship is a workflow with no input channel. What a human decides is decided at the checkpoint. 06
  • It cannot shrink the suite to go green. A hook denies test edits while a run is fixing a failure, and a settle round with a red suite pushes nothing (1.14). 13
  • Agents cannot overwrite each other. The planner separates tasks that touch the same file; with --isolate-waves each runs in its own worktree. 06
  • A reviewer has to prove what it read. Each review dimension hands in a coverage ledger. No proof, no MERGE (1.12). 15
  • A dismissal needs a file:line. Reviewers run blind, one per dimension; skeptics must cite the diff to dismiss a blocker or warning (1.15). 06
  • The merge verdict is computed, not opined. MERGE, HUMAN or BLOCK comes from the CLI. The worst signal wins, and missing evidence counts against you. 15
  • Nothing is silent, nothing phones home. interlock limits prints every cap, every degradation is a named banner, and Interlock makes no network request of its own (1.15). 04

Example output of Interlock's guard-tests hook. While a run is fixing a failing check, an edit to test/pricing.test.mjs is denied, with the reason that a run making a failing check pass must fix the code under test, not weaken the check. An edit to src/pricing.mjs is allowed.

The hook's own words, from running it against a throwaway directory. The guards →

Built with itself. Every feature here started as a spec and shipped through the same checkpoint: more than 80 changes, one folder each.

How it compares

Already using something?

  • Plan mode plans for one session, then the same agent builds. Interlock keeps the spec in your repo, builds with fresh parallel agents and keeps gating after you approve.
  • OpenSpec: keep it. Interlock drives the same CLI and files, and adds the run: exploration, a spec review, parallel waves, verification, a commit and a pull request. 03
  • Spec Kit runs five commands per feature, "reviewing each result before continuing". Interlock asks for one read. Spec Kit supports far more agents; that is the trade.
  • Superpowers teaches the agent a discipline through skills it reads. Interlock takes the parts with a right answer out of the prompt: a hook denies the edit, an exit code enforces the cap.
You do Builds it Holds the rules Ends at
Plan mode approve a plan the same session your permission mode edits in your working tree
OpenSpec propose, apply, archive one assistant, task by task skills, and a CLI that validates the artifacts ticked tasks, archived specs
Spec Kit five commands, a review after each your agent, in its chat templates and a constitution Converged
Superpowers sign off a design, then say go a fresh subagent per task skills the agent reads your pick of merge, PR, keep or discard
Interlock read one spec parallel agents in waves exit codes, hooks, a runtime that cannot ask a tested commit, then a verdict on the PR

From each project's own README, November 2026. Nobody has benchmarked these against each other, us included. Sources and the longer version: 08.

The flow

The Interlock flow: bootstrap once per repo; for every change, spec, then you read the spec, then ship; when you want them, settle and archive. Two commands, one human checkpoint.

Two commands per change, and you read the spec between them. Settle and archive carry it from the commit to the merge.

When Command What you get
once per repo /interlock:bootstrap Your repo, described in specs
every change /interlock:spec "idea" A reviewed, implementation-ready change. Then it stops
every change You read the spec Ten minutes, with a checklist. The only place a human is required
every change /interlock:ship Parallel agents, your tests, one commit. Asks nothing
after the commit /interlock:settle The pull request, with the merge verdict on it
after the merge openspec archive <change> The living specs catch up

The ship meter pane during the recorded run: wave 1 with three lanes marked ok and the model that served each, the verify checkpoint between the waves, wave 2 with two lanes running and one pending, then verify-final, commit and close.

The same run, drawn live inside Claude Code (2.1.295+). The pane observes; the CLI decides. The ship meter →

Flags, and the commands you may never need

Flags

Flag What it changes
ship --review Runs the adversarial review before the commit
ship --strict Adds remediation, handoff artifacts and a conformance check
ship --solo · ship --waves Forces the plan shape the classifier would otherwise choose
ship --tdd Runs the change's failing-test section first
spec --continue Skips the checkpoint when the readiness gate passes. 05 says what that cannot catch

Commands you can run any time, on their own

Command Use it to
/interlock:explore Investigate the repo with parallel read-only investigators
/interlock:review-code Run the adversarial review on its own
/interlock:fix-tests Repair a red suite by root cause, without weakening a test
/interlock:graph Build and query the code graph
/interlock:report Read the indicators over the run corpora. It gates nothing
/interlock:manual-test-plan Write a manual UI test plan from a change and its commits
/interlock:explain-code Walk through a module, or explain the last commit
/interlock:evals Turn an observed model failure into an eval case
/interlock:docs-digest Compress the docs and specs into one primer for agents
/interlock:dispatch Find the right skill when you are not sure which applies
/interlock:commit Write one feature-level commit from the change

Panes, for watching

Pane Draws
/interlock-meter The ship run
/interlock-spec The spec run, with the checkpoint card
/interlock-settle Every /interlock:settle pass on a pull request, with or without --review
/interlock-preflight The session's doctor report
/interlock-handoff The resume card after a halt

The checkpoint card (interlock checkpoint <change>) lists the questions to ask of a spec. When a pane prints a command, it offers it as a drafted action; you submit it yourself.

In the terminal

Command Tells you
interlock doctor Whether anything would stop a zero-touch run on this machine
interlock limits Every cap the loop obeys
interlock drift Changes never archived, specs that cite deleted files, changed files no spec describes
interlock merge-confidence The MERGE / HUMAN / BLOCK verdict

Every subcommand: 07.

Words you will see
Change One unit of work: a folder under openspec/changes/<name>/ holding proposal.md, design.md, tasks.md and delta specs
Delta spec The behaviour a change adds or alters, written as Given/When/Then scenarios
Living spec openspec/specs/: what the system does today. Archiving a change folds its delta specs in
Checkpoint Your read of the spec, between spec and ship. The one step a human must do
Skill / workflow A skill is instructions Claude follows in the conversation, and it can ask you questions. A workflow is a script the Claude Code runtime executes, and it cannot
Wave / lane A wave is a batch of tasks that run in parallel; a lane is one agent's slot in it
Halt ship stopped, said what finished and what it needs from you. 04 decodes each one

Every term, defined from the ground up: 09 — From prompt to workflow.

Then settle the pull request

/interlock:settle --create --review
  1. Opens a draft pull request, described from the spec and the diff.
  2. Reviews the diff and posts the findings.
  3. Fixes them in rounds. Each round runs your suite before it commits, so a red round pushes nothing.
  4. Answers every finding: fixed, open or new.
  5. Labels it MERGE, HUMAN or BLOCK, with the evidence in the description.

Its verdict on one of Interlock's own pull requests. It did not flatter us:

The merge-confidence block /interlock:settle wrote on Interlock's pull request 33: HUMAN, score 54, 6 of 17 gating signals clean. One signal needs a fix (two added source files no spec names), three need a person (risk class high, a diff over the size bands, two open decisions) and three need more evidence. Labels: interlock/human-review and interlock/score-54.

Every line verbatim from the description of #33; the signal table and the commit line under it are left out.

It never merges and never approves: a person presses the button. It needs gh or glab signed in. The GitHub loop has run end to end; the GitLab lines are not exercised. 15 — Merge confidence

Turn the gates up

Default ship trusts your test suite: a green suite, one commit. Add the rest as the loop earns it.

Add What it does Cost
ship --review Blind reviewers, one per dimension, then skeptics. You see what survived, and how many did not The expensive part of a run. 06
ship --strict The review, plus remediation, a manual test plan for UI changes, a commit walkthrough and a conformance check against the spec The previous default. 01
interlock merge-confidence --require-merge The settle verdict as a required CI check. Exits 1 unless MERGE Some setup. 15
REVIEW.md Your repo's policy: paths out of review scope, paths that always need a human One file. 12

What it costs

  • Claude Code only. It is the default and supported host, because the guarantees come from its workflow runtime. Cursor and Copilot are not supported; a runner for other hosts is experimental.
  • Review spends tokens. --review, --strict and settle --review are the expensive part of a run, so default ship leaves them out.
  • Guards fail open. A hook that cannot tell a run is live allows the edit, by design.
Fine print: OpenSpec, the doctor, other hosts, the network, the CLIs
In one line
Your own OpenSpec Used as it is when it is on your PATH. Otherwise a pinned copy is installed on first use
The doctor Runs at every session start. ! interlock doctor prints the full report
Other hosts interlock-run is experimental, and only you start it
The network Interlock makes no network request of its own and reads no credential
The CLIs Three zero-dependency Node binaries, also on npm

Your own OpenSpec · 01

  • A copy already on your PATH is used as it is. interlock openspec which prints which copy resolves.
  • Otherwise the first /interlock:spec or /interlock:bootstrap runs interlock openspec provision: about 16 MB from the npm registry, into the plugin's data directory and nowhere else.
  • To install it yourself instead:
npm install --location=global @fission-ai/openspec@2.0.0

The doctor · 07

  • The session-start check is interlock doctor, run for you.
  • Type ! interlock doctor at the Claude Code prompt for the full report. It carries a ready-to-paste snippet that allowlists every command a run needs, and exits 1 when something would stop a zero-touch run.
  • The plugin puts the CLI on the PATH of Claude Code's shell only. For your own terminal, install the npm package and keep it at the plugin's version (16).

Other hosts (experimental) · 07

  • interlock-run drives the same loop over the Claude Code CLI, any Agent Client Protocol (ACP) agent, OpenAI Codex or Qwen Code.
  • You start it yourself. No slash command does, and /interlock:ship never falls back to it.
  • Two caveats, both bannered by the runner:
    • Billing. claude -p, the Agent SDK and ACP are the usage Anthropic flagged for separate metered credit. The Workflow runtime behind /interlock:ship is the exempted path.
    • Model tiers. Codex and Qwen need the planner's model tiers mapped with INTERLOCK_MODEL_MAP. An unmapped tier is bannered, never silently run on your default.
  • The older interlock-ship-acp still works, prints a deprecation line, and is removed in the next minor.
  • Code Mode is out of scope.

The network

Interlock makes no network request of its own and reads no credential. The plugin declares no option to ask you for one.

  • Requests that belong to other tools. What each of these sends is its own:
    • /interlock:settle has the model run gh, glab and git fetch under your own sign-in.
    • interlock openspec provision runs npm to install the pinned OpenSpec from the npm registry when none is on your PATH.
    • The vendor CLIs a run spawns inherit the environment, as any child process does.
  • What it reads on your machine. interlock doctor, the session-start check and interlock run start read Claude Code's settings files: managed, user (~/.claude/settings.json), project and local. They use only permissions, promptCacheTtl, subagentPromptCacheTtl and advisorModel, so they can say whether a run would stop on a prompt. No other key or value is used, printed or sent.
  • What it runs on your machine. interlock verify exec runs the command it is passed, which the loop takes from the commands in .claude/testing/profile.json; the coverage baseline runs that profile's coverage command. Both run through a shell (/bin/sh on macOS and Linux) in your environment, as you would run them yourself. Whatever those commands send is theirs, not Interlock's.
  • Being reached while away. Interlock sends no push of its own. On a Claude Code that supports mods, the meter asks the engine for a local notification on a halt, a close, a first quiet stretch and a checkpoint. Claude Code's Remote Control can push to your phone when a long task finishes or a session needs you, with nothing configured in Interlock.

The CLIs on their own · 07

Binary What it is
interlock The policy engine. Every gating subcommand exits 1 when it blocks
interlock-graph A local, deterministic code graph. No vector store, no network
interlock-run The experimental runner above

The plugin puts all three on Claude Code's PATH. To put them on yours:

npm install --location=global @renzrollon/interlock@1.17.0

The reference and every environment variable are in 07.

Docs

Start with 01 — The first hour, and keep 04 — When it stops open during your first ship. Then 02 for reading a spec in ten minutes and 06 for the mechanisms. Only ever prompted a coding agent? 09 defines every term once.

Every doc
01 — The first hour Install to first shipped change
02 — The checkpoint How to read a spec in ten minutes
03 — OpenSpec vs Interlock What composes with what
04 — When it stops Every halt and banner, and what to do
05 — Continuity When --continue may skip the human read
06 — Why it works The mechanisms, low-level, with the costs stated
07 — CLI and configuration Every subcommand, environment variable and host
08 — The Interlock harness The parts of the harness, what holds on each host, and the comparison with other tools
09 — From prompt to workflow New to agentic workflows? Every term defined, then why ship is a script
10 — Ship and spec for prompt-only engineers Primer, review of spec+ship, token and quality tactics
11 — The indicators What interlock report measures and why it gates nothing; whether to commit the run corpora
12 — Repository review policy The optional REVIEW.md: what it can change and what it cannot
13 — The guards The hooks, the stage marker's lifecycle, and the fail-open rule
14 — Evals What a consumer's run is checked by, why no model evals run in your CI, how to file a failure
15 — Merge confidence What the MERGE / HUMAN / BLOCK verdict reads, signal by signal, and how it reaches a pull request or a CI job
16 — Upgrading What an upgrade keeps, what a resume across versions does, and how to keep the CLI at the plugin's version

Development

git clone https://github.com/renzrollon/interlock && cd interlock
npm test                      # no dependencies to install first
claude --plugin-dir .         # load it without installing

Built on OpenSpec by Fission AI · MIT

About

Spec-driven development for Claude Code, layered on OpenSpec. You read one spec; parallel agents ship it to a tested commit.

Topics

Resources

Code of conduct

Contributing

Security policy

Accessibility

Stars

62 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages