The short answer
We pick Spec Kit when the work is mostly new and OpenSpec when the work is mostly change to something that exists. The deciding questions are about the project, not the tools: how much is already live, how big each change is, who reviews it, and who will maintain the specs after we leave.
Comparisons of the two tools usually list features and commands. Those matter less than people expect. Both are open source, both store Markdown in your repository, and both work with the common coding agents. The real difference is the shape of the spec over time, and that shape should match the shape of the work. Our method page on Spec Kit and OpenSpec describes how each flow runs. This note is about how the choice gets made.
The four questions we ask first
Before choosing, we answer four questions in the first days of a Spec Sprint. Each one points towards one tool or the other. Most projects answer clearly enough that the choice makes itself, and the rest end up using both.
- How much of the frontend is already live? Little or none points to Spec Kit. Most of it points to OpenSpec.
- How will change arrive? In large, well-defined features, Spec Kit. As a steady stream of small adjustments, OpenSpec.
- Who reviews each change, and what do they need to see? A reviewer approving a whole feature wants the full spec. A reviewer approving a tweak wants only what changed.
- Who maintains the specs after handover? A team that will keep building new features can keep Spec Kit’s per-feature folders. A team that mostly maintains will find one living spec easier to keep true.
The decision table
This is the table we work from. It is not a rule. The answers to the four questions above decide it, and we write the reason for the choice into the plan, so the client’s team can revisit it later.
| Project situation | Choice | What decides it |
|---|---|---|
| A new product, nothing built yet | Spec Kit | Full specs per feature leave no gaps, and nothing existing needs protecting |
| A new section of an existing product, mostly self-contained | Spec Kit for the section | It behaves like a new product with a few known integrations |
| A live frontend with a backlog of small changes | OpenSpec | Each change is a small delta, quick to write and review |
| An audit with a list of findings to fix | OpenSpec | Each finding is already a change against what exists |
| A gradual rebuild, route by route | Both | OpenSpec protects live routes; Spec Kit specifies the new ones |
| An ongoing retainer on a mature product | OpenSpec | Change arrives continuously and in small pieces |
| A short prototype that may be thrown away | Neither, at first | A lightweight spec is enough until the prototype earns a future |
A new product: why Spec Kit
On a new product, every feature has to be specified anyway, because nothing exists to describe it. Spec Kit’s per-feature specs, written after a constitution and reviewed phase by phase, give the client a complete picture of what will be built before any code. The phases also give natural sign-off points.
The cost of Spec Kit’s thoroughness is size. Its documents are long, and each feature lives in its own folder and usually its own branch. On a new product that cost is small, because the alternative is discovering the gaps later. The constitution is the part that matters most here: written once, it holds every later feature to the same accessibility, performance and privacy bar.
A live product: why OpenSpec
On a live product, most work is change: a modified rule, a new state, a removed step. Writing a full spec for each change would be slow and would bury the change itself in pages of unchanged text. OpenSpec writes only the delta, as ADDED, MODIFIED or REMOVED requirements, against one spec that describes today’s behaviour.
That makes review faster and safer. The reviewer sees exactly what changes, next to what it changes. Once the change is accepted, the delta merges into the living spec, so the spec keeps describing the product as it really is. For a team inheriting a mature codebase, that single, current spec is often the most useful document they receive.
### MODIFIED Requirement: Session timeout
Members are signed out after 15 minutes of inactivity (was: 30 minutes).
### ADDED Requirement: Timeout warning
One minute before sign-out, a dialog offers to keep the session, and is announced to screen readers.
Each requirement then gets its own acceptance criteria and tests, exactly as in a new feature. The delta format changes how the spec is organised, not how rigorously it is checked.
When a project needs both
Many projects are partly new and partly live. A gradual rebuild is the common case: the old frontend keeps running while new routes replace it one at a time. We use OpenSpec for changes to what is live and Spec Kit for the new routes, with one constitution shared by both, so the same rules apply everywhere.
The two coexist without friction because they produce the same kinds of files. The constitution, criteria, tests and trace reports are shared. Only the folder layout differs. When a new route goes live, its spec joins the living spec, and future changes to it become deltas.
| Part of the product | Tool | Shared across both |
|---|---|---|
| Live routes and components | OpenSpec deltas | Constitution |
| New routes being built | Spec Kit feature specs | Acceptance criteria format |
| Fixes from an audit | OpenSpec deltas | Quality gates |
| Releases | Either | Trace reports |
What we do not choose on
We do not choose on popularity, on which tool has more features, or on which one we like better. Tool details change between versions, and the official repositories, GitHub Spec Kit and OpenSpec, are the place to check current commands. We also do not choose on lock-in, because neither tool creates any: both leave plain Markdown in your repository.
If your team already uses a spec format, that usually wins. We map our artifacts onto your format rather than replacing it. What we care about is that criteria are written, tested on every change, and reported at release. The tool is a means to that.
Two examples, side by side
Two neutral examples show how the questions play out. In both, the constitution, the criteria format, the quality gates and the trace reports are identical. Only the way the spec is organised differs, and that follows from what already exists on the day we start.
A subscription platform with no frontend yet. Nothing is live, the first release has a defined scope, and the client’s product owner wants to approve each feature as a whole. We write a constitution, then a Spec Kit spec for each feature: sign-up, plans, checkout, account. Each moves through specify, plan and tasks, and the product owner signs off on each spec before building starts.
A member portal that has been live for years. The backlog is long and made of small items: a changed timeout, a new error message, a removed step, an accessibility fix. We write one living spec describing today’s behaviour, starting with the areas the backlog touches. Then every backlog item becomes an OpenSpec proposal with a few deltas. Reviews take minutes, because the reviewer sees only what changes.
In the second case the first step is often an Audit. It finds the gaps in the current frontend and writes them as deltas, which become the first proposals.
What the client sees either way
From the client’s side the difference is mostly invisible. You review criteria written in plain sentences, approve changes in writing, and receive a trace report at each milestone. Spec Kit gives you a full feature spec to approve. OpenSpec gives you a short list of changes. Both end with a release you can check line by line against what you agreed.
Changing your mind later
The choice is reversible. A product specified with Spec Kit can move to OpenSpec once it is live and change slows to small increments: the existing feature specs become the starting point of the living spec. Moving the other way is rare, but a large new feature on an OpenSpec project can always get a full Spec Kit spec of its own.
This is why we record the reason for the choice in the plan. When the project changes shape, the team can see why the choice was made and whether that reason still holds.
How to make the choice on your project
Answer the four questions above for your product, then find your row in the decision table. If the answer is unclear, you probably need both. If you would like us to make the call with you, it is one of the first decisions in a Spec Sprint. If you have a live frontend with known problems, an Audit produces its findings as OpenSpec deltas, ready to build.