Open source v0.4 · python 3.11+

Get AI-written code as close to production-ready as possible.

The bugs that reach production are the ones your harness was supposed to catch, but couldn't, including the ones sitting in code an agent already fixed and called done.

Across hundreds of real runs, half of all blockers were found in code a model had already fixed and verified.

syncade is open source. It runs on your machine, on accounts you already authenticated, against your repo.

$ {{ installCmd }}
Read the source

then syncade --install-skill to get /syncade in your harness

Spec sheet
{{ row.k }} {{ row.v }}
How it works

Same as a professional team of developers.

Someone writes the code, independent developers review it, and push back for changes until no bugs are found. Only automated, and on demand. Every round spawns fresh CLI subprocesses in throwaway worktrees, because isolation is what makes a reviewer a reviewer instead of the author again, more politely.

01
Snapshot
HEAD plus the diff under review.
02 · blind
Reviewer A
02 · blind
Reviewer B
Parallel, in separate throwaway worktrees, each with a shell. Different prompts, different findings.
03
Cold synthesizer
A third blind judge consolidates both into one findings.md. Unanimous blockers can't be dismissed.
04
Verdict
Mechanical. Computed from findings and test legs. The LLMs never set the exit code.
05 · on NO-SHIP
Producer
A developer that never saw the review being written. It gets findings.md, fixes what it says, and commits to your branch. Then strangers read it again.
↺ back to 01 · up to 10 rounds

The verdict is an exit code

Which means it composes. Gate a hook on it, branch a script on it, or just read it. No parsing prose to find out whether it passed.

{{ c.n }}
{{ c.d }}
Why the harness misses

Everything in your workflow measures the code against the exact same intent and context that produced it.

And that is exactly the thing that is broken. A bug is the behavior nobody thought of, and every check in the loop is built out of what someone thought of, so this is not a coverage gap you close by adding gates. 378 of 407 blockers were raised in rounds where every mechanical check was green.

What you're relying on
What it actually proves
Why the bug walks straight through
{{ g.t }}
{{ g.p }}
{{ g.w }}
What syncade adds
The yardstick from outside
A reader who wasn't there, holding the brief as a separate document, with a throwaway checkout and permission to run things. It is not checking whether the code does what the author meant. It is checking whether the code does what the brief said, and then trying to break it. Every row above is downstream of one understanding. This is a second one.
The mechanism

Five ways syncade gets outside the author's head.

A second opinion only counts if it was formed independently. Every design decision here exists to keep the reviewers from inheriting the reasoning that produced the code, because a reviewer who has read your session is just the author again, more politely.

{{ g.n }}
{{ g.t }}
{{ g.d }}
One command

Point it at a brief. Get a verdict.

Two blockers in round one, on a branch where all 118 tests passed. That is the whole product.

~/your-repo · syncade
{{ l.t }}

illustrative run · real output is denser · replays automatically

Evidence

323 runs. 407 blockers. Ten weeks.

Every number here is measured, and reproducible from the run corpus in .syncade/runs. Nothing below is a projection.

{{ s.n }}
{{ s.d }}

Tests encode the behavior someone thought of.

Every class in this table is defined by being the behavior nobody thought of, which is exactly why the test that would catch it was never written.

keyword-derived and overlapping; 130 blockers matched no bucket. Read it as the shape of the corpus, not a partition.

Defect class n share Why self-review misses it {{ c.c }} {{ c.n }} {{ c.s }} {{ c.w }}

Three examples of actual bugs

BLOCKER
{{ r.t }}
{{ r.g }}

What it costs

90 priced runs, valued at API rates. A clean single-round review lands nearer $2; the tail is multi-round loops where the producer rewrites code each round.

{{ c.k }}
{{ c.v }}
Presets

Zero config works. Everything is a knob if it doesn't.

A preset sets the roster, the thinking budget and the round count in one flag. Underneath it, every actor in the loop is a config key in .syncade/config.toml — and every one of them can be overridden per run from the CLI, without editing a file.

--preset {{ p.flag }}
{{ p.name }}
{{ p.d }}
{{ p.spec }}
Nothing in the loop is hard-coded

Swap the producer, add a third reviewer, put a different lab in the judge's seat, or hand a slow repo a longer leash.

{{ k }}
Install

Four minutes, no account.

syncade drives the CLIs you already have authenticated. It makes no network calls of its own.

{{ s.n }}
{{ s.t }}

{{ s.d }}

{{ s.code }}
Straight answers
{{ f.q }}

{{ f.lead }} {{ f.a }}

Your agent has never once been told it was wrong by someone who wasn't there.

That is the one thing that ever made any of us better at this. syncade is the whole process, not a second opinion: readers who weren't there, a verdict they don't get to write, and a developer that fixes what they found and comes back for another pass.

$ {{ installCmd }}
Star the repo
Know when it changes

Release notes when a version ships, and the numbers behind them. Nothing else.

no spam · unsubscribe in one click