Three diffs that look like clean refactors
Every one of these passes CI.
- const active = users.filter(u => u.status !== 'deleted')+ const active = users.filter(u => u.status === 'active')
Cleaner. Obviously equivalent. Except the fixtures only ever contained active and deleted — production also has invited and suspended. Those users just disappeared from every report, every export, and the monthly billing count. Nobody noticed for nine days, and then someone asked why the numbers moved.
- const day = parseISO(row.created_at)+ const day = new Date(row.created_at)
CI runs in UTC, so the tests agree. Your users are in UTC+2. Every event between midnight and 02:00 now lands on the previous day. The daily dashboard is off by a few percent — never enough to look broken, exactly enough to be wrong.
- const res = await api.post('/orders', payload)+ const res = await withRetry(() => api.post('/orders', payload), { attempts: 3 })
The tests mock the API, so a retry costs nothing. In production the first call succeeded and timed out on the response. It retried twice. Three orders, one customer, and a support ticket that took two days to trace back to this line.
None of these are exotic. All three ship green. All three were written by something that had no way of knowing what your data actually looks like.
Which one of those three have you actually shipped?
One email when there's something to show. I'll ask what your last silent breakage was — that's the whole onboarding.
I've been on the wrong side of this.
I built an AI-driven testing tool once — Playwright and Claude, running in production. It worked. It also taught me exactly where this kind of thing fails.
It was a terminal-friendly visual testing tool: it screenshotted every change automatically and showed you how the change actually looked in production. Easy to drive from an AI coding agent, easy to drop into a manual or automated workflow.
More than once, a small patch to a ticket shipped with a minor bug and broke something on production. After the suite existed, I could scan screenshots across a hundred-plus files and spot the break in the client-facing frontend before it ever left my machine.
LLMs are fast, smart, and not reliable — a probabilistic tool produces probabilistic results. A proper test pipeline turns it into a fast, near-deterministic one: it doesn't remove the human from the loop, it sharply reduces how often you're needed in it.
That's the gap I'm building for. Not more tests — the right ones, generated against what your system really sees.
Implement fast, ship fast — just don't run the red light.
What Beforemath does
- 01Reads what your code actually meets. Your real enum values, your real null rates, your real timezones — not the four rows in your fixtures.
- 02Generates the tests your suite is missing. The fourth status. The empty array. The retry that isn't idempotent. The paths nobody wrote a fixture for.
- 03Runs on every AI-generated PR. Fails loudly, in review, while it's still cheap.
Who this is for
A fit if
- A meaningful share of your PRs are written or heavily assisted by AI
- Your test suite predates that shift
- You ship data, reports, or anything where "quietly wrong" is worse than "obviously broken"
Not a fit if
- You have strong coverage and a review culture that's keeping up
- You're looking for a linter or a static analyzer — this is neither
Questions people actually ask
- Why do AI-generated changes break production when the tests pass?
- Generated code is written against your code, not against your data. A refactor can be logically equivalent for the values in your fixtures and wrong for the values in production — a fourth enum case, a non-UTC timezone, a retry that isn't idempotent. The suite passes because it never had a fixture for the case that breaks.
- What does Beforemath actually do?
- It reads what your code actually meets in production, generates the tests your suite is missing for those cases, and runs them on every AI-generated pull request — so failures show up in review, while they're still cheap.
- Is this a linter or a static analyzer?
- No. Those read the code. This one reads what the code meets: real enum values, real null rates, real timezones.
Beforemath is early.
There's nothing to sign up for yet — no product, no trial, no demo. There is a list, and it's short. That's the honest version of a signup button. What exists: me, a working prototype from a previous life, and a short list of teams I'm designing this with before I build it.
If any of the three diffs above felt familiar, email me. I'll ask what your last silent breakage was, and you'll get an honest answer about whether this would have caught it.