fluidfix watches your test suite and restores mechanical regressions byte-exact — zero AI tokens per decision. Teach it a bug class once, from one example; every future member is fixed free, forever. Unknown bugs are refused loudly, never guessed.
# deploy, commit, forget — real run, 0.7s $ fluidfix guard . --commit [16:43:06] billing.py: repaired line 2 in 4 suite runs (0.7s): - return p * (1 - rate) + return p * (1 + rate) committed $ git log --oneline -1 2298af3 fluidfix: restore billing.py:2
# one example teaches the CLASS — kernel never edited register(4, "missing-get-default", 'a .get(key) with no default poisoning arithmetic', re.compile(r"\.get\((\"[^\"]+\")\)"), lambda line, o: re.sub(r"\.get\((\"[^\"]+\")\)", r".get(\1, 0)", line)) $ fluidfix guard . --commit --dictionary company_rules.py payroll.py: repaired · invoices.py: repaired · metrics.py: repaired
# CI gate: exit 0 = green or repaired · exit 2 = needs a human $ fluidfix guard . [17:52:54] REFUSED: fault is outside the taught vocabulary refusal report: .fluidfix/last_refusal.json $ echo $? 2 # it never guesses — that is the feature
see it run
Install from PyPI, a regression ships, the guard repairs and commits it, a novel class is refused, taught from one example, and the whole class becomes free — every duration on screen is measured.
how it works
The decision layer is a machine-authored, exhaustively verified expression — not a model, not a lookup table. Run fluidfix selfcheck and re-derive every law on your machine in about a second.
Traceback frames ∪ failing-test coverage ∪ AST spans find the fault file and line. Mechanical, zero tokens.
The kernel maps the observed fault class to its repair from ONE worked example.
Your own test suite accepts or rejects every candidate. Rejected candidates roll back byte-exact.
Empty mask → loud refusal, untouched tree, and a machine-readable teach-me signal. Never a plausible guess.
On 33 real-library bugs: 26/27 byte-exact in-vocabulary vs 22/27 for full Opus 5 debugging — which also shipped five suite-green-but-different edits. fluidfix shipped zero.
One worked example buys an entire fault class. Every future instance routes in four integer instructions — re-runs, audits, renumberings included.
Green suite: touches nothing. Unknown class: refuses, exits 2, writes the teach-me report. The failure mode is a statement, not a wrong edit.
what it fixes — honestly
fluidfix learns a whole bug class from one example when the fix is a rule you apply to the broken line. When a fix needs a value that isn't on the line, it refuses instead of guessing. Both columns below are from a real generalisation test — one example taught, then run on different, unseen bugs of the same class.
Flipped >= / >, swapped + / −, off-by-one literals, and/or, True/False, ==/!=, a .get() missing its default, swapped return operands. One example = the whole class, free forever.
Tested: 11/11 unseen bugs repaired byte-exact.
The right variable name, the right constant, the right guard for this function — information the broken line doesn't carry. One example of name→email can't know the next bug is count→total. fluidfix leaves these for a human.
Tested: 0/5 — every one safely refused, zero wrong edits.
That refusal is the product: an unattended repair tool is only trustworthy if its failure mode is a loud "not this one," never a silent wrong edit. Measured record across every test: many repairs, zero wrong ones.
one example, measured
Each class was taught from one worked example, then tested on different, held-out bugs of the same class. These results are enforced as tests in the repo's CI — if they stop being true, the build goes red.
| Class shape | Held-out bugs | Result |
|---|---|---|
| Rule-shaped — flipped +/−, comparison strictness, off-by-one literals, missing .get default… | 11 bugs · 4 classes | 11/11 repaired byte-exact |
| Value-shaped, repo-searchable — the wrong attribute, name, or constant, where the correct value exists somewhere in your repo: fluidfix mines the candidates (bounded at 32) and your suite judges each one. One registration covered .name→.id and .count→.total — different values, same class. | held-out set | repaired byte-exact |
| Value not in the repo — the right answer was a computation that exists nowhere in the codebase. | 1 case | every candidate failed → refused, tree byte-identical |
The contract underneath all three rows: fluidfix has never made a wrong repair — every fix passes your full suite or is rolled back byte-for-byte, and what it can't prove, it refuses. Precision is bounded by your suite's strength, which is also why it rewards teams that test.
students & open source
fluidfix is open source (AGPL) — students, hobby projects, and open source pay nothing, ever. If your repo has a pytest suite, you can guard it in three steps. Never written a test? The quickstart teaches you the whole idea in 2 minutes — call your function, check the answer.
pip install fluidfix
fluidfix selfcheck
Selfcheck re-proves the whole engine on your machine in about a second — expect SELFCHECK PASS.
cd your-project
fluidfix guard . --commit
Green tests: it touches nothing. A mechanical bug: it finds the file itself, repairs it byte-exact, and commits fluidfix: restore …. An unknown bug: it refuses loudly — that one's yours to fix, and honestly, that's the good practice.
Add .github/workflows/fluidfix.yml so every push is checked:
name: fluidfix
on: [push]
jobs:
guard:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with: {python-version: "3.12"}
- run: pip install -e . pytest pytest-cov fluidfix
- run: fluidfix guard .
# exit 0 = green or auto-repairable
# exit 2 = a real bug fluidfix won't guess at — fix it yourselfFull walkthrough with expected outputs (every step CI-tested): docs/DEMO.md. Built something cool with it? Email me — student stories get featured.
pricing
Checkout is being set up — pre-booking costs nothing today, locks the launch discount, and puts you in the first-ten cohort. We email you when payment opens; you can walk away any time.
Enterprise (unlimited repos, SSO, SLA) from $10k/yr — talk to us. Every number on this page comes from measured runs: benchmark & per-bug data.
pre-book
Reserve launch pricing or book a free 20-minute live demo — I run fluidfix on your repo while you watch. No card, no charge.