“Done” that means done.

Development governance for coding agents.

Specstride takes a Spec Kit feature to done, phase by phase, unattended: the engine runs the tests, a separate reviewer judges the real change, and only then is the phase signed and committed.

curl -fsSL https://specstride.ai/install.sh | bash -s -- plugin

Open source under Apache-2.0. Runs on your machine. Your models, your keys. For Claude Code, dsh and Hermes, on Linux.

specstride · a real run (2026-11-04)
===== PHASE 1 — the overlapping work  (2026-11-04T03:21:24.358Z) =====[001-par-overlap] phase 1 attempt 1: proposer started[001-par-overlap] verification: npm test -> passed[001-par-overlap] phase 1 attempt 1: rejected----- phase 1 REJECTED on attempt 1/3 ---------- diagnostician: phase 1 attempt 1 (unmet set changed) -----[001-par-overlap] phase 1 attempt 2: proposer started----- accelerator: phase 1 attempt 2/3 (dsh) — acting on the hint for T002,T003 -----[001-par-overlap] verification: npm test -> passed[001-par-overlap] phase 1 attempt 2: approved===== PHASE 1 APPROVED (attempt 2) =====----- git checkpoint: phase 1 approved -----
  1. The tests passed. The reviewer still said no.
  2. Diagnosed first, in a separate session.
  3. Retried on the two unmet tasks only.
  4. Approved: tasks ticked, a signed record, one commit.
The engine's own output, trimmed, from a stored log: the phase's tests passed, the reviewer still said no, the rejection was diagnosed, and the narrowed second attempt was approved.

What you get

For people who leave agents running on real work and need to trust the result when they come back. Each benefit comes from a specific part of how the loop is built.

"Done" that means done
because Tests run before review, an independent reviewer approves, and the commit happens or the run fails.
Unattended runs you can walk away from
because A detached runtime, capped loops, a clean stop, and resume after a crash or a kill.
Fewer wasted attempts
because Diagnosis narrows each retry to the unmet tasks, and the router escalates model tiers by rule.
Your models, your keys
because The implementer and the reviewer are resolved independently. The engine has Claude, dsh, Codex, pi and prime adapters and a generic descriptor (cli, openai-chat, anthropic-messages). The hosts ship Claude and dsh today.
An audit trail
because Approval records, one commit per phase, rule ids on every decision, OTLP and Loki telemetry.
Safe parallelism
because Fenced worker trees, audited deltas, and the full gate on the merged tree.
Extensible without forks
because 19 versioned extension points (specstride.<name>/<major>), each with a conformance suite in @specstride/testkit.
Nothing leaves your machine
because Specstride runs no service of its own, so nothing is sent to its authors.

A plain agent loop, or Specstride

A single agent session is one loop with no brakes, and an agent that grades its own work says “done” when it isn't. Specstride treats the loop itself as the thing to engineer: which loops exist, what ends each of them, and what happens when one gets stuck.

Who says "done"

A plain loop: The agent that did the work.

Specstride: The tests first, then a separate reviewer.

What "the tests pass" means

A plain loop: A line in the agent's own report.

Specstride: The engine ran the phase's frozen checks itself, before any review.

What a retry is

A plain loop: A blind retry.

Specstride: A diagnosis first, then an attempt narrowed to the unmet tasks.

How it ends

A plain loop: It can end with "it went quiet".

Specstride: A named stop reason with a fixed exit code.

What a kill costs

A plain loop: The loop stops there.

Specstride: No engine process survives, and the next start resumes where it stopped.

Why a decision was made

A plain loop: Nothing to explain it after the fact.

Specstride: A rule id and a table version on every decision.

What is left at the end

A plain loop: The agent's word.

Specstride: One commit per approved phase, and a signed approval record for each.

How it works

For each phase of a Spec Kit feature, the same gate. A phase moves on only when a separate reviewer approves it.

  1. The implementer works through the phase's tasks.
  2. The engine runs the tests itself.
  3. The reviewer — a separate session, with no tools — reads the actual change against the tasks and answers with a one-time nonce.
  4. Approved: tasks ticked, one commit, signed record. Rejected: back to the implementer with the reasons, up to 3 attempts. A rejection that names new unmet tasks is diagnosed first, and the next attempt is narrowed to them.
Claude Code · ~/specstride-example

You: Run Specstride on the feature in this repo.

Skill(specstride:specstride-run)

Bash(specstride --protocol)

1

Bash(specstride contract derive --repo ~/specstride-example)

[SPECSTRIDE-DERIVE] contract=pipeline:001-slugify:contract sources=3 tasks=7 declarations=0 commands=0 mappings=0 verification=required reason=configured

Bash(specstride contract derive --repo ~/specstride-example --output pipeline:001-slugify:contract --next-batch)

{"schema":"specstride.judgment/1","id":"001-slugify-1","items":[],"bytes":91,"remaining":0}

No items to judge. Promote, validate, render.

Bash(specstride contract promote pipeline:001-slugify:contract && specstride contract validate pipeline:001-slugify:contract && specstride contract render pipeline:001-slugify:contract)

promoted to validated: 001-slugify

valid validated launch contract: 001-slugify

rendered ~/specstride-example/.specstride/state/pipeline/001-slugify/launcher

bundle ~/specstride-example/.specstride/state/pipeline/001-slugify/bundle/4f65fd8220c7a6ec8934

Bash(specstride launch --mode run)

[SPECSTRIDE-LAUNCH] run=run-launch-mwiuycpo state=running

… the first `wait --until-change --timeout 60` printed nothing: the run was still going. The whole run took 1 min 25 s — three phases, each implemented, tested, reviewed and committed …

Bash(specstride wait --until-change --timeout 60)

[DIGEST] state=completed exit=0 last-stage=run-001-slugify evidence=~/specstride-example/.specstride/state/pipeline/001-slugify/runs/launch-mwiuycpo

Specstride ran on the `001-slugify` feature and the run completed with exit code 0. - **Contract:** the CLI built the launch contract `pipeline:001-slugify:contract` from 3 sources with 7 tasks; verification was marked required. There were no judgment questions to answer. - **Checks:** the contract was promoted, it passed validation, and it was rendered. The launcher and bundle are stored in Specstride's own state, not in your code. - **Mode:** you gave no comment and no mode, so I launched in `run` mode with no comment. `[SPECSTRIDE-LAUNCH] run=run-launch-mwiuycpo state=running` The first wait printed nothing, which means the state hadn't changed yet. The second wait returned the digest: [DIGEST] state=completed exit=0 last-stage=run-001-slugify evidence=~/specstride-example/.specstride/state/pipeline/001-slugify/runs/launch-mwiuycpo

See it run, inside Claude Code

A real session on the example repository, a tiny Node project with one Spec Kit feature in three phases. One sentence starts it; the plugin's skill derives and validates the launch contract, launches the run and reports back in the CLI's own lines, so your session keeps its context.

Replayed from the session's transcript and trimmed: commands are shown as the CLI call, paths are cut to the repository, waits are shortened. The engine's own log of a phase is the one at the top of this page.

git log --oneline
fa55273 specstride: phase 3 approved — Short slugs and display titles
7325f44 specstride: phase 2 approved — Accents, symbols and errors
1e40fd7 specstride: phase 1 approved — Basic slugs

Each approved phase becomes its own commit.

A verdict an agent can't talk its way past

A model judging another model's work, the pattern called LLM-as-a-judge, is only worth something when the judge is independent, reads the real change, and cannot be imitated. Specstride's reviewer is that judge, and the engine around it is what makes its verdict count.

Why the verdict counts

Independent

The reviewer is a separate session, chosen independently of the implementer, on any provider. A phase is never approved without one.

Evidence, not a summary

It reads the actual change against the phase's tasks, including the contents of new files. The implementer's notebook and repair history are withheld from it.

Facts before opinion

The engine runs the tests itself, before the reviewer sees anything. A phase whose tests fail never reaches review.

Cannot be imitated

The verdict is bound to a one-time nonce for that attempt. Text planted in the evidence cannot pass for it, and an implementer that prints "APPROVED" achieves nothing.

Outside text is data

Everything from outside the runtime enters through one ingress, where it is size-capped and framed as data. It fails closed.

A verdict on the record

An approval is a signed record outside the implementer's write scope, read back and verified again on resume. A forged or missing approval stops the run.

  • Independent

    The reviewer is a separate session, chosen independently of the implementer, on any provider. A phase is never approved without one.

  • Evidence, not a summary

    It reads the actual change against the phase's tasks, including the contents of new files. The implementer's notebook and repair history are withheld from it.

  • Facts before opinion

    The engine runs the tests itself, before the reviewer sees anything. A phase whose tests fail never reaches review.

  • Cannot be imitated

    The verdict is bound to a one-time nonce for that attempt. Text planted in the evidence cannot pass for it, and an implementer that prints "APPROVED" achieves nothing.

  • Outside text is data

    Everything from outside the runtime enters through one ingress, where it is size-capped and framed as data. It fails closed.

  • A verdict on the record

    An approval is a signed record outside the implementer's write scope, read back and verified again on resume. A forged or missing approval stops the run.

The controls around it

Approved means committed

Every approved phase becomes its own commit. If a commit is blocked, the run never reports success: the engine exits 1 and says so.

Secrets held back

Credentials are redacted from what the reviewer and the traces see, and a credential found in the change blocks the commit.

Integrity tripwires

Fingerprints before and after every check, protected paths and pinned toolchains catch an implementer that edits what it must not. A tripwire stops the run until a human clears it.

Configuration narrows, never widens

Project configuration can only restrict a run. Anything that widens capability comes from user scope, the environment or flags.

Containment by default

Adapters declare containment levels C0 to C3. The strongest one available is the default, and C0 is an explicit opt-in.

Everything observable

One primary event writer per run and a read model for status. Every decision carries its rule id, so an audit can follow a run from launch to the last commit.

  • Approved means committed

    Every approved phase becomes its own commit. If a commit is blocked, the run never reports success: the engine exits 1 and says so.

  • Secrets held back

    Credentials are redacted from what the reviewer and the traces see, and a credential found in the change blocks the commit.

  • Integrity tripwires

    Fingerprints before and after every check, protected paths and pinned toolchains catch an implementer that edits what it must not. A tripwire stops the run until a human clears it.

  • Configuration narrows, never widens

    Project configuration can only restrict a run. Anything that widens capability comes from user scope, the environment or flags.

  • Containment by default

    Adapters declare containment levels C0 to C3. The strongest one available is the default, and C0 is an explicit opt-in.

  • Everything observable

    One primary event writer per run and a read model for status. Every decision carries its rule id, so an audit can follow a run from launch to the last commit.

The price is stated too: every attempt makes at least two model calls, on your own subscription or key. The diagnostician that reads a stuck phase gives no verdict; nothing it says approves or rejects.

Built for unattended work

Autonomy is useful only when you can trust what it reports, and when the run is still there after you close the terminal. Every loop in a run has a defined end.

01 pipeline stages

ends: Each stage has its preconditions. A run ends only on a named stop reason with a fixed exit code.

02 phases of a run

ends: A phase ends when the reviewer approves it: tasks ticked, one commit, a signed record.

03 phase attempts

ends: Capped at 3 per phase. The third rejection ends the run with exit 2.

04 passes

ends: Watchdogs and breakers end a pass. A long job yields instead of waiting.

05 micro-loop cycles

ends: Inner checks end at a checkpoint: keep, repair or unresolved (the micro layer).

Detached from your terminal

One runtime root per run, detached from the shell that started it, with a workspace lock and lease, a process registry and an inbox for requests.

Kill the engine mid-run, nothing survives

SIGKILL the engine in the middle of a phase and no engine process is left running. Start it again and the run picks up where it stopped.

A clean stop

The stop verb of the specstride CLI ends the run at the next safe boundary: the workers finish their pass, the merge check runs, the record closes whole, no survivor.

Every loop has an end

Attempts are capped, passes have watchdogs and breakers, and every way a run can stop is a named stop reason with a fixed exit code. Nothing ends with "it went quiet".

Stuck phases get unstuck

A rejection that names new unmet tasks is diagnosed first, in a separate session, and the next attempt is narrowed to those tasks. Two narrowed attempts never follow each other.

A router with no I/O

Check order, loop layer and escalation to the next model tier come from a pure function over versioned rule tables, so a run can be explained after the fact.

Yields instead of dead waits

Long jobs run detached while the pass yields. A wait that can no longer complete ends early instead of burning its timer.

It learns, with guardrails

The learning layer suggests per-phase settings from the run's own telemetry and reverts any change that makes things worse. Off unless you turn it on.

Detached from your terminal

One runtime root per run, detached from the shell that started it, with a workspace lock and lease, a process registry and an inbox for requests.

Kill the engine mid-run, nothing survives

SIGKILL the engine in the middle of a phase and no engine process is left running. Start it again and the run picks up where it stopped.

A clean stop

The stop verb of the specstride CLI ends the run at the next safe boundary: the workers finish their pass, the merge check runs, the record closes whole, no survivor.

Every loop has an end

Attempts are capped, passes have watchdogs and breakers, and every way a run can stop is a named stop reason with a fixed exit code. Nothing ends with "it went quiet".

Stuck phases get unstuck

A rejection that names new unmet tasks is diagnosed first, in a separate session, and the next attempt is narrowed to those tasks. Two narrowed attempts never follow each other.

A router with no I/O

Check order, loop layer and escalation to the next model tier come from a pure function over versioned rule tables, so a run can be explained after the fact.

Yields instead of dead waits

Long jobs run detached while the pass yields. A wait that can no longer complete ends early instead of burning its timer.

It learns, with guardrails

The learning layer suggests per-phase settings from the run's own telemetry and reverts any change that makes things worse. Off unless you turn it on.

Parallel units, opt-in

Mark tasks [P] in your Spec Kit tasks.md and turn the layer on. Tasks whose files are disjoint run at once, each in its own worker tree, behind eight admission checks. The engine audits and merges their work and runs the full gate on the merged tree before the reviewer sees the phase; tasks whose files overlap are refused, with the reason printed, and run in order.

It is built to be safe, not sold as a speed-up: the option's own document sets no target and promises no saving. Groups run only when the implementer runs on dsh, the one harness whose concurrent sessions are tested; with any other harness the layer stays off and the run continues in order.

~/.config/specstride/config.yaml
# your user configuration, read from this file only
loop:
  parallel:
    units: on
    allow_detect: on

One engine, three hosts, your models

Specstride core is the engine. The Claude Code plugin, the dsh host and the Hermes host are thin hosts over it, so the loop, the gates, the records and the commits are the same in whichever agent you already use.

Claude Code plugindsh hostHermes host
Runs inClaude CodedshHermes
Built onSpecstride core
Its skills run the core 0.1.0 CLI from your PATH.
Specstride core
Pins the core 0.1.0 release tarballs by sha256.
Specstride core
Pins the core 0.1.0 release tarballs by sha256.
Pick it whenYou work in Claude Code.You work in the DeepSeek Harness.You work in Hermes.
InstallOne command, or 12 steps by hand. Last run as written on 2026-11-16.
The steps
One command, or 7 steps by hand. Last run as written on 2026-11-08.
The steps
One command, or 7 steps by hand. Last run as written on 2026-11-14.
The steps
You drive it with2 skills
specstride-run specstride-doctor
3 skills
specstride-run specstride-reverse specstride-doctor
3 skills
specstride-run specstride-status specstride-curate
StatusPlugin 0.1.2 on core 0.1.0. Runs on Linux; macOS is not verified.Version 0.1.0, built from a clone: nothing is on npm yet. Linux is verified, macOS is not. The live probe inside dsh ran on 2026-11-06; the trigger suite and the release gate are a paid lane a person starts.Built from a clone: nothing is on npm yet. Linux is verified, macOS is not. The pinned engine has no reverse verb yet, so the installer skips the reverse skill.
The loopThe same in all three, because the engine underneath is the same: same gates, same records, same commits.

Choose the implementer and the reviewer independently

By default both are separate Claude sessions through your Claude Code login. Either can instead be any provider and model your DeepSeek Harness (dsh) reaches. The loop stays the same whichever you choose: same gates, same records, same commits.

either role, on any provider dsh reaches
# any provider and model your dsh reaches, either role
SPECSTRIDE_PROPOSER=dsh:<provider>/<model>
SPECSTRIDE_CRITIC=dsh:<provider>/<model>
  • Claude

    implementer · reviewer

    The default. Implementer and reviewer are two separate sessions through your Claude Code login.

  • dsh

    implementer · reviewer

    Implementer or reviewer on any provider and model your DeepSeek Harness (dsh) reaches. Parallel units need dsh as the implementer.

Install

One command per host, or the same steps by hand. Each path was run as written, on the date shown on the install page.

Claude Code

Install the engine's CLI, then the plugin in Claude Code, then take the ready-made example feature through its first run before pointing it at your own repository. The plugin is skills only; they run the specstride CLI from your PATH, and nothing is on npm yet, so the CLI is packed from a clone.

In one command — runs the steps below, in order (read the script)

install.sh
curl -fsSL https://specstride.ai/install.sh | bash -s -- plugin
Or step by step: the 12 commands it runs
Claude Code
# the engine CLI the plugin's skills run
git clone https://github.com/mairp/specstride-core
cd specstride-core
npm ci
# packs the release tarballs into .build/release/
node scripts/pack-release.mjs
npm install -g .build/release/specstride-0.1.0.tgz
# prints the CLI protocol, 1
specstride --protocol
# then the plugin, in Claude Code
/plugin marketplace add mairp/specstride-plugin
/plugin install specstride@specstride-marketplace
# to try it on a ready-made feature first
git clone https://github.com/mairp/specstride-example
cd specstride-example
claude
# then say
Run Specstride on the feature in this repo.

On your own repository — any git repo with a specs/NAME/tasks.md and a test script in package.json — say the same sentence. Each approved phase becomes its own commit.

Useful? A ★ star on mairp/specstride-plugin helps others find it.

dsh

Build the dsh host from a clone, install it with the engine's CLI from the tarball it pins, then put the three skills into your repository. Nothing is on npm yet.

In one command — runs the steps below, in order (read the script)

install.sh
curl -fsSL https://specstride.ai/install.sh | bash -s -- dsh
Or step by step: the 7 commands it runs
dsh
git clone https://github.com/mairp/specstride-dsh
cd specstride-dsh
# resolves the pinned engine tarballs; nothing compiles
npm install
# renders the skills and the shim, runs every build gate
npm run build
# specstride-host-dsh and the specstride CLI this repository pins
npm install -g . vendor/core/specstride-0.1.0.tgz
# in your repository; the skills go into .dsh/skills/
specstride-host-dsh install --project
# six findings, one line each
specstride-host-dsh doctor

Then, in a dsh session in your repository, say "run the specstride-run skill in dry-run on the feature". It plans and validates and launches nothing. Drop "in dry-run" to run the feature for real.

Useful? A ★ star on mairp/specstride-dsh helps others find it.

Hermes

Build the Hermes host from a clone, install it with the engine's CLI from the tarball it pins, then put the skills and the plugin into a dedicated Hermes profile. Nothing is on npm yet.

In one command — runs the steps below, in order (read the script)

install.sh
curl -fsSL https://specstride.ai/install.sh | bash -s -- hermes
Or step by step: the 7 commands it runs
Hermes
git clone https://github.com/mairp/specstride-hermes
cd specstride-hermes
# resolves the pinned engine tarballs; nothing compiles
npm install
# renders the skills and the shim, runs every build gate
npm run build
# specstride-host-hermes and the specstride CLI this repository pins
npm install -g . vendor/core/specstride-0.1.0.tgz
# skills and plugin into the dedicated profile; run it again → already installed, unchanged
specstride-host-hermes install --profile specstride
# eight host.* findings, one line each, no model
specstride-host-hermes doctor

Then, in a Hermes session on your repository (hermes -p specstride), say "run the specstride-run skill in dry-run on the feature". It plans and validates and launches nothing. Drop "in dry-run" to run the feature for real. Add --with-kanban to the install for the kanban board.

Useful? A ★ star on mairp/specstride-hermes helps others find it.

Core (CLI, for host builders)

The dsh and Hermes hosts pin the core, and the Claude Code path above installs its CLI. Install it on its own only to run the specstride CLI from a shell or to build a host on it. Build the engine from a clone and pack its release. Nothing is on npm yet.

In one command — runs the steps below, in order (read the script)

install.sh
curl -fsSL https://specstride.ai/install.sh | bash -s -- core
Or step by step: the 7 commands it runs
Core (CLI, for host builders)
git clone https://github.com/mairp/specstride-core
cd specstride-core
npm ci
# packs the four release tarballs into .build/release/
node scripts/pack-release.mjs
npm install -g .build/release/specstride-0.1.0.tgz
# prints the CLI protocol, 1
specstride --protocol
# in your repository
specstride doctor

specstride --help lists every verb. Each verb takes --json, --verbose and -h. To build a host, start from @specstride/host-kit and pass the conformance suite in @specstride/testkit. See the core README.

Useful? A ★ star on mairp/specstride-core helps others find it.

Costs and limits, stated plainly

A tool that asks for your trust should state its limits. These are the product's own, from its READMEs and its security notes.

  • Linux only, so far

    macOS is not verified: no Mac has run it.

  • It costs more than a single session

    Every attempt makes at least two model calls, on your own subscription or key.

  • The implementer runs with your permissions

    Specstride runs coding agents in your repository, and the implementer can run shell commands. Run it on work you trust.

  • A trail, not a vault

    The implementer can read the local approval key, so approval records are a trail, not proof against an adversary on your machine. The secret scan is a net, not a guarantee.

  • Nothing is on npm yet

    Every path builds from a clone. The one-command installer does that for you.

  • Version 0.1

    Parallel units are off by default and run only with dsh as the implementer.

Open source, Apache-2.0

The whole product, free and open source under the Apache licence.

Runs on your machine

No service of its own: nothing is sent to Specstride's authors. Run records, approvals and logs stay in ~/.specstride/, and telemetry export is off by default; when you turn it on, it goes only to endpoints you configure.

Your models, your keys

The implementer and the reviewer go through your Claude Code login by default, or through the provider you set with dsh. Each provider's own data policy applies.

Star or fork on GitHubExampleSecurity notesContributing

Questions

Isn't an LLM judging an LLM circular?

It would be, if the judge only read the implementer's report. This is LLM-as-a-judge with the parts the bare pattern leaves out. The engine runs the tests itself before the reviewer sees anything. The reviewer is a separate session with no tools, chosen independently of the implementer and on any provider. It reads the actual change against the phase's tasks, not a summary it is handed. Its verdict is bound to a one-time nonce and written as a signed record, so planted text cannot pass for it. It is a second opinion held to evidence, not a proof: the reviewer section shows what reaches it and what is held back.

Why not just CI?

Keep your CI. It tells you after a push. Specstride gates each phase before its commit exists: the engine runs the phase's checks itself, a phase whose tests fail never reaches review, a rejection goes back to the implementer with the reasons, and only an approved phase becomes a commit.

Why not just loop the agent until it says it is finished?

Because then the agent that did the work decides when it is done, and an agent that grades its own work says "done" when it isn't. A plain loop also has no brakes. The comparison puts it beside Specstride, where attempts are capped, every stop has a named reason and an exit code, and a rejected phase is diagnosed before it is retried.

Which one do I want — the plugin, dsh, Hermes or core?

The host that matches the agent you already use: in Claude Code, the plugin; in the DeepSeek Harness, the dsh host; in Hermes, the Hermes host. Each is one command: curl -fsSL https://specstride.ai/install.sh | bash -s -- plugin (or dsh, hermes). The core is not a fourth choice but the engine all three are built on: the plugin's skills run its CLI and the other two pin its release, so the loop, the gates, the records and the commits are the same whichever host you pick. Install the core alone only to run the specstride CLI from a shell or to build a host for another agent.

What is loop engineering?

An agent session is a loop with no brakes. Loop engineering designs the loops around it instead: pipeline stages, phases, attempts, passes and micro cycles, each with a defined end, deterministic checks before any reviewer opinion, and a rule-driven router that decides what happens when a loop gets stuck. The core page shows the engine layer by layer.

Do I need Spec Kit?

You need the format, not its tooling. A feature is a specs/NAME/ directory with a tasks.md: ## Phase N: Title headings and - [ ] T001 … tasks are what Spec Kit writes, and you can write them by hand. spec.md and plan.md beside the tasks, if you have them, go to the implementer with the tasks.

Which models can it use?

Any you trust. Specstride is an orchestrator and does not rank models. The implementer and the reviewer are chosen independently: by default both are separate Claude sessions through your Claude Code login, and either can instead be any provider and model your DeepSeek Harness (dsh) reaches.

What happens when a phase keeps failing?

It is not just started again. When the reviewer's rejection names unmet tasks the phase has not been diagnosed for yet, a diagnostician — a fresh session, never the implementer's — reads the phase and writes a hint, and the next attempt is narrowed to those tasks with the hint as its first instruction. Both are on by default (SPECSTRIDE_DIAGNOSTICIAN=false or SPECSTRIDE_ACCELERATOR=false turns one off). A phase gets up to 3 attempts; after the third rejection the run stops with exit 2, the reasons are in the output, and a new run resumes from the phases already approved.

What leaves my machine?

Nothing is sent to Specstride's authors; there is no service of its own. What you choose goes to your model providers — the implementer reads the feature's spec, plan, tasks and the reviewer's feedback; the reviewer reads the tasks, the test output and the change. Each provider's own data policy applies. Run records, approvals and logs stay in ~/.specstride/ on your machine, and telemetry export is off by default.

What does it cost?

Nothing for Specstride itself — it is free and open source under Apache-2.0. Each phase makes at least two model calls on your own subscription or API key, so a run costs more than a single session would.

Does it run on macOS?

macOS is not verified — no Mac has run it. Linux is what it runs on today.

Is it from Anthropic?

No. Specstride is not affiliated with Anthropic.

How do I contribute?

Issues and pull requests on the plugin repository, following CONTRIBUTING.md — add a test with each change, keep the import boundaries, and run the formatter before you push. Good first issues are labelled good first issue. Questions and bugs go to issues.

Every phase reviewed, signed and committed.

Open source. Runs on your machine. Your models, your keys.

curl -fsSL https://specstride.ai/install.sh | bash -s -- plugin