“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 -- pluginOther hosts, and the steps it runsGitHub
Open source under Apache-2.0. Runs on your machine. Your models, your keys. For Claude Code, dsh and Hermes, on Linux.
===== 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 -----
- The tests passed. The reviewer still said no.
- Diagnosed first, in a separate session.
- Retried on the two unmet tasks only.
- Approved: tasks ticked, a signed record, one commit.
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.
- The implementer works through the phase's tasks.
- The engine runs the tests itself.
- The reviewer — a separate session, with no tools — reads the actual change against the tasks and answers with a one-time nonce.
- 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.
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.
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.
# your user configuration, read from this file only
loop:
parallel:
units: on
allow_detect: onOne 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 plugin | dsh host | Hermes host | |
|---|---|---|---|
| Runs in | Claude Code | dsh | Hermes |
| Built on | Specstride 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 when | You work in Claude Code. | You work in the DeepSeek Harness. | You work in Hermes. |
| Install | One 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 with | 2 skillsspecstride-run specstride-doctor | 3 skillsspecstride-run specstride-reverse specstride-doctor | 3 skillsspecstride-run specstride-status specstride-curate |
| Status | Plugin 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 loop | The 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.
# 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)
curl -fsSL https://specstride.ai/install.sh | bash -s -- plugin
Or step by step: the 12 commands it runs
# 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)
curl -fsSL https://specstride.ai/install.sh | bash -s -- dsh
Or step by step: the 7 commands it runs
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)
curl -fsSL https://specstride.ai/install.sh | bash -s -- hermes
Or step by step: the 7 commands it runs
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)
curl -fsSL https://specstride.ai/install.sh | bash -s -- core
Or step by step: the 7 commands it runs
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.
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