Published August 23, 2026 · one of the RedMirror role playbooks
Your AI wrote the code and it runs. That is not the same as it being safe to take money. This playbook adds one step between "it runs" and "it ships": the same kind of model, with the RedMirror Reflection kernel behind it, checks whether your app can reach a state it should not, and proves each bug with the exact calls that trigger it.
Everything below is a real run. An AI built a small checkout module, then a cheap model with the kernel behind it found, proved, and fixed three money bugs in that code, and the kernel re-verified each fix.
You move fast because you describe what you want and the model builds it. The gap is that a model writes confident, plausible code, and the bugs that survive are logic bugs: a total that can be charged at zero, coupons that stack, a cart that changes after it is paid. Those slip past a quick read and past "it worked when I tried it". Reflection is the check you run before you ship, and it needs no security expertise from you: it hands you a plain-English attack path and a fix the kernel has re-verified.
From a naive spec ("a cart, items, coupons SAVE10/SAVE20/FREESHIP, a confirm that charges it"), the model produced a working checkout.js module: createCart, addItem, applyCoupon, confirm. It runs. Every happy path returns the right number. That is exactly the state most vibecoded code ships in.
The agent modelled the checkout as a state machine and stated the invariants a payment flow must keep. The kernel searched every reachable state and grounded three separate bugs, each with a real gate stamp.
$ docker run -e ROLE=vibecoder ... reflection-playbooks == PHASE 1 — vibecode the app (qwen/qwen3-coder-next) == (model writes checkout.js: createCart, addItem, applyCoupon, confirm) == PHASE 2 — reflect: find + prove (deepseek/deepseek-v4-flash) == GROUNDED zero-charge confirm on an empty cart stamp 4b2af5dedfbc15b3 GROUNDED coupons stack: SAVE10 then SAVE20 = 28% off stamp de5dc2ede52a90be GROUNDED cart mutates after it is paid stamp 971273bf10c27524 (each fix then re-verified: kernel PROVED) == PHASE 3 — gate == reflection: 3 finding(s) grounded, nothing left open. audit exit: 0 --- .redmirror-reflect/session.jsonl --- {"note":"claim REFUTED and answer matches","status":"GROUNDED","stamp":"de5dc2ede52a90be"}
Each "GROUNDED" is a kernel refutation with a reachable call sequence, stamped by the gate — not a model opinion.
| Bug the kernel proved | The reachable attack |
|---|---|
| Zero-charge confirm | createCart() → confirm() with no items — the order is charged 0. |
| Coupon stacking | addItem → applyCoupon('SAVE10') → applyCoupon('SAVE20') — the second coupon discounts the already-discounted total, so 1000 → 900 → 720 (28% off) instead of a single 20%. |
| Post-confirm mutation | confirm() → addItem() — items are added after the cart is paid, so the total no longer matches what was charged. (applyCoupon guards this; addItem forgot to.) |
For each finding the agent applied a fix and the kernel re-checked it: reject a confirm on an empty cart, recalculate every coupon from the raw subtotal instead of the running total, and guard addItem on cart.paid the way applyCoupon already did. On the patched module the kernel proved each invariant holds and redmirror-reflect audit exits 0.
That is the difference between "it ran when I tried it" and "the kernel could not drive it into a bad state." You ship the second one.
Reflection installs as one binary and is driven by the coding agent you already use. Point it at the app your AI just wrote:
curl -fsSL https://dist.redmirror.io/install.sh | sh
redmirror-reflect license activate <key>
redmirror-reflect init claude # or cursor, codex, gemini, windsurf, pi, ...
It runs on your machine, so the prototype you have not decided to trust a vendor with stays with you, and the kernel search uses no tokens. For a deeper walkthrough of a vibecoded checkout, see Vibecode with confidence and the verify step for vibe-coded apps.
Vibecoding compresses the AI-native SDLC into one person and a model, which means the test and deploy gates land on you. Reflection is that gate, made small enough to run before you push.
It adds a verification step between 'it runs' and 'it ships'. Your AI writes the code; then the same kind of model, with the RedMirror kernel behind it, checks whether that code can reach a state it should not. You get proven bugs with the exact call sequence that triggers them, and each fix is re-verified by the kernel before you ship.
An AI built a small checkout module and the kernel grounded three bugs: confirming an empty cart charges zero, applying two coupons stacks their discounts (SAVE10 then SAVE20 gives 28% off instead of a single 20%), and items can still be added after the cart is paid so the charged total no longer matches. All three were fixed and the kernel then proved each fix holds.
No. Each finding comes with the exact call sequence that triggers it, and the agent proposes a fix that the kernel then re-checks. You read a plain-English attack path and confirm the fix closed it, rather than reverse-engineering the vulnerability yourself.
No. RedMirror Reflection runs as a single binary on your own machine, and the kernel search uses no tokens. You point it at your own model, local or hosted, and the code stays with you. That is why it works even for a quick prototype you have not decided to trust a vendor with yet.
Check the code your AI wrote before it takes money. Install the binary, point it at your app and your own model, and ship the version the kernel could not break. First month free, then $4.99/month, cancel any time.