The trust layer between coding agents and production
Breakspec is the merge gate for your coding agents’ pull requests. It checks each change while the agent works, sends every bug it proves straight back to the agent to fix, and puts a receipt on the pull request: what was asked, what changed and what was proven.
- Works with Claude Code, Cursor and Codex
- 14 languages
- Runs in a sandbox with no network
- Coding agent
- Breakspec prove, fix loop
- CI / merge gate
- Production
- What was asked
- “Add a discount for annual plans, paid in monthly instalments.”
- What changed
annual_price,apply_discountandsplit_bill- What was proven
- Does what was asked
- Doesn’t break what worked
- The logic holds
- Survives retries, timeouts and races
First attempt broke a rule:
split_bill(1, 2) → [0, 0]. The agent fixed it before opening this pull request.- What wasn’t checked
- Data stays where it belongs
- Data survives the change
- It stays within budget
- Compiled code is memory-safe
Cut the {bs.} No opinions, just inputs that fail.
Coding agents write code faster than anyone can review it. So a person still reads every diff before anything ships, because nobody trusts what agents write. Breakspec sits between the agent and production and reports only the bugs it can prove. The aim is agents that ship on their own, with proof.
What a change has to prove before it ships
For an agent’s change to reach production without anyone reading the diff, it has to prove everything below.
- 01
It does what was asked
The change in behaviour matches what you asked for, and nothing else changed.
- 02
It doesn’t break what worked
Old and new versions agree wherever the change wasn’t meant to apply, and past bugs stay fixed.
- 03
The logic holds
- Round trips
- What it writes, it can read back, and what consumes its output accepts it. This caught the TypeScript bug.
- Invariants
- Totals add up, and nothing is lost, duplicated or out of range. Example: 1 cent split two ways returned
[0, 0]. - Equivalence
- Two ways of doing the same thing agree: cached and fresh, an incremental and a clean build, the same moment in any time zone.
- Idempotence
- Doing it twice equals doing it once.
- 04
It survives the real world
Retries, timeouts, partial failures and races, replayed exactly.
- 05
Data stays where it belongs
Coming soonOne customer’s data never reaches another, permissions hold, and secrets stay out of logs.
- 06
Data survives the change
Coming soonMigrations and backfills lose nothing.
- 07
It stays within budget
Coming soonLatency, memory use and cost stay within the limits you set.
- 08
Compiled code is memory-safe
Coming soonNo memory corruption, leaks or data races in compiled code.
How it works
Breakspec works on its own and stops for a person at three points: before any code goes to an AI model, when rules need approving, and when a fix is ready to review. The panels follow one example function, split_bill, through each step.
- 01
It finds where to look
Breakspec ranks your codebase by where a bug would cost most and what your agents just changed. You don’t pick functions or write specs.
Where to look firstExamplebilling.py · split_billMoney. Changed today by your agent.billing.py · paginateChanged today by your agent.billing.py · apply_discountMoney.
- 02
It works out what must always be true
It writes rules in plain English from what you asked your agent and what your code documents. A person approves each rule before it can block a merge.
Rule for split_billExampleThe shares add up to the bill.
- You asked
- “Split the bill evenly between everyone.”
- Docstring
- “Split a bill evenly between people, in cents.”
Approved - 03
It proves every bug
Each bug comes with an input that fails on demand and a failing test in your own test suite. If Breakspec can’t replay a failure, it doesn’t report it. Each finding also says how far its rule rests on what your code promises, so you can tell a bug from a disagreement about intended behaviour.
Proven bug in split_billExample- Input
split_bill(1, 2)- Returns
[0, 0]- Why
- The shares add up to 0, not 1.
- Replays
- Every time
- Test
- Fails in your test suite
- Rule
- Documented in the docstring
- 04
Your agent fixes it
Breakspec writes a fix request, and your own Claude Code fixes the bug on a separate, isolated branch.
billing.py, fixed by Claude Code on its own branchExampledef split_bill(total_cents, people): - share = round(total_cents / people) - return [share] * people + share, extra = divmod(total_cents, people) + return [share + 1] * extra + [share] * (people - extra) - 05
Breakspec checks the fix
It replays the failing input, searches again and runs your tests before a person sees the fix. Nothing merges or pushes without a person.
Fix checkExample- The failing input now passes
- Searched again: no new failures
- Your test suite passes
- The fix isn’t a special case for that one input
Ready for your review
Every agent PR arrives with proof
Breakspec runs as a required check on your agents’ pull requests, the way CI does. What it adds is the proof.
- 01
In the agent’s loop
Breakspec checks each change while your agent works. When it proves a bug, the fix request goes straight back to the agent, so most bugs never reach a person.
- 02
A receipt on every pull request
Each agent pull request arrives with what was asked, what changed, what was proven and what wasn’t checked, so the person reviewing it reads a receipt, not a diff.
Your policy reads the receipt and decides what merges without a person. Coming soon
- 03
Sweeps of the code you already have
Breakspec also checks the risky code that’s already there. Each bug it proves becomes a fix from your agent, with its own receipt, ready to go up as a pull request through the same gate.
How it stays safe
Security detailsRuns in a sandbox
Checks run on your machine or in your CI, in a sandbox with no network access.
Asks before sending code
Before any code goes to an AI model, Breakspec shows you exactly what will be sent and asks.
Uses your model provider
Requests go through your own model provider, or the Claude Code you already sign in to.
People hold the gate
Only a person can approve a rule. Nothing merges or pushes without a person.
Where it’s going
Today a person approves the rules and every merge. These are the parts we’re building to finish the rows marked Coming soon, so that your own policy can decide when an agent’s change ships without a person.
The Living Spec
A record of what your system must always do, mined from prompts, tickets, docs and production, and approved by people. Agents check it before they write code.
ComingFull-system sandbox
Your whole system in a deterministic sandbox, so bugs that span services replay exactly.
ComingProof-carrying merges
Your policy reads each pull request’s receipt and decides what merges without a person.
ComingThe network
Proven bugs become patterns that improve every customer’s checks.
ComingAgent Reliability Index
A public record of which coding agents introduce which bugs.
ComingQuestions
Do I have to write specs or choose what to check?
No. Breakspec ranks your codebase by where a bug would cost most and what your agents changed, then writes rules from what you asked your agent and what your code documents. You approve the rules you agree with. You can also point it at one function or write rules yourself.
How is this different from AI code review?
A reviewer reads a change and comments on what might be wrong. Breakspec runs the code and reports a bug only when it has an input that fails on demand and a failing test you can run yourself. It doesn’t review style or design, so keep a reviewer for those.
Does it fix the bugs it finds?
Your own Claude Code fixes each one on a separate, isolated branch. Breakspec then replays the failing input, searches again and runs your tests before you see the fix. A fix that only special-cases the failing input isn’t marked as verified.
Can it merge code without a person?
Not today. A person approves every rule that can block a merge, and nothing merges or pushes without a person. Letting your own policy decide which proven changes merge on their own is on the roadmap.
Where does my code go?
Checks run on your machine or in your CI, in a sandbox with no network. Before any code goes to an AI model, Breakspec shows you exactly what will be sent and asks. It uses your own model provider, or the Claude Code you already sign in to.
Which languages and tools does it work with?
Python, TypeScript, JavaScript, Go, Rust, Java, Kotlin, C, C++, C#, Ruby, PHP, Swift and Elixir. It checks code from any agent, or written by hand. Run it from the command line, as a GitHub check on every pull request, as a pre-commit hook, or from inside Claude Code, Cursor or Codex.
What if a rule is wrong?
Each finding says how far its rule rests on what your code actually promises. If your code documents the behaviour a rule calls a bug, the finding is labelled as likely not a bug. Rules are files in your repository, and you can change or drop any of them.
Does a clean run mean my code is correct?
No. It means Breakspec found no failure in what it checked. It doesn’t guarantee there are no other bugs.
When can I use it?
We’re letting people in from the waitlist in batches. Tell us what you’re building when you join.
Breakspec is in early access
We’re letting people in from the waitlist in batches. Tell us what you’re building and which coding agent you use, and we’ll email your invite.