Navian Open Source
GitHub Contact
← All posts

10× productivity by AI coding agents needs 1,000× the testing.

Seshu Guddanti · Navian AI · August 17, 2026 · 3 min read
reliabilityDSTAI codetesting

We're Navian AI. We build Navian Pulse, a real-time decision engine for banks. It scores each event in under a millisecond and decides, in that moment, whether to let money move. When a payment is about to leave someone's account, Pulse is the thing that says yes or no. So a bug here isn't an annoyance — it's a wrong answer on a real person's money.

We built Pulse the way the fastest teams build now: we leaned heavily on generative AI to write the code. That's how a small team ships something this ambitious, this fast.

But that speed comes with a catch. AI writes code that is fast and looks right. What it can't do is sense the failures that only appear when timing and bad luck line up: two things happening at once and corrupting each other, a write that vanishes when a machine crashes mid-operation, a number that comes out quietly wrong. These don't show up in a code review. They pass every normal test. They surface only when the exact wrong sequence of events happens in production — on someone's money.

So we built the answer we needed. Tools that generate the bad luck on purpose — the crashes, the collisions, the exact wrong ordering — and replay each failure until it's fixed. Where a team hand-writes fifty tests, our simulator runs hundreds of thousands of distinct failure scenarios in minutes. Fifty tests find the bugs you thought of. Hundreds of thousands find the ones you didn't.

And here's what makes it practical: none of it costs a token. You don't write a hundred thousand tests — you write one, and the simulator runs it a hundred thousand ways, each from a different seed. The AI writes the code; the simulator generates the chaos, for free. Testing 1,000× harder doesn't cost 1,000× more.

That's the shift: if AI writes 10× the code, you have to test it 1,000× harder — and now you can, because the testing scales for nothing.

And the prize is bigger than speed. Trustworthy code at 10× is leverage: automate the work your team still does by hand, pay down the tech debt you never had time for, build products — and whole business models — that weren't economical before, and out-ship competitors still writing everything the slow way. Testing is what lets you bank that upside instead of gambling on it.

None of this is specific to banks. The moment AI writes a meaningful share of your code, the bottleneck moves from writing it to proving it holds up. So we're open-sourcing the tools we built for ourselves — starting with navian-dst, deterministic simulation testing for Rust. Install is two commands, and you don't wire it in by hand: the CLI finds the nondeterminism and rewrites the parts it can prove safe, and your AI coding agent — Claude Code, Codex, or Cursor — finishes the rest from the list.

It's live now — opensource.navian.ai, or cargo add navian-dst. I'd genuinely love your feedback.

Update: prompted by a reader who noted that seeded replay proves a run reproducible but not that its checks are right, we added two commands to the CLI — navian-dst invariants, which fails a simulation that runs but asserts nothing, and navian-dst review, which argues with the invariants you did write (flagging the ones that can never fail or ignore the state). If the same AI writes the code and the tests, something has to check that the tests actually test — without itself pretending to know what "correct" means for your system.

Resources

navian-dst

On deterministic simulation testing

← Back to all posts