Software Verification in the Age of Coding Agents
Episode
47 min
Read time
2 min
Topics
Health & Wellness, Remote Work, Fundraising & VC
AI-Generated Summary
Key Takeaways
- ✓Deterministic Simulation Testing architecture: Antithesis deploys software as a controlled Linux target running at 48x parallelism by default, fast-forwarding sleep calls and injecting controlled nondeterminism. A 15-minute PR-level run simulates hours of real execution time, while overnight 12-hour runs can simulate roughly three months of software runtime for high-confidence regression coverage.
- ✓Unknown-unknown testing gap: Standard tests encode known behavior as regression anchors, leaving the most damaging bugs untested. DST instead breadth-first searches the full state space by branching timelines at any execution point, changing thread scheduling, randomness, or fault injection mid-simulation — reaching failure modes no human would think to specify in advance.
- ✓SQLite WAL bug reproduction benchmark: A concurrency bug present in SQLite for ten years, triggered only once in production at Tailscale, was reproduced by Antithesis in 15 minutes using a generic workload covering all SQLite operations with equal probability — no prior knowledge of the bug's location was required to find it.
- ✓Property-based verification over path-based tests: Instead of encoding specific execution sequences, define system-wide invariants — such as SQLite's built-in `PRAGMA integrity_check` — and instruct Antithesis to evaluate them at random simulation points. This prevents AI-generated code from overfitting to narrow test cases, forcing implementations toward genuinely correct general-purpose behavior.
- ✓AI coding shifts effort toward specification and verification: As AI compresses code-writing time, engineering effort should rebalance toward precise specifications that derive testable properties, and toward verification nets that validate all possible execution paths against those properties — not just the paths developers anticipated when writing the original feature.
What It Covers
Carl Spera from Antithesis explains how deterministic simulation testing (DST) works by running software in a fully controlled environment that explores thousands of execution paths autonomously, surfacing rare concurrency and distributed system bugs that conventional unit, integration, and stress tests consistently miss.
Key Questions Answered
- •Deterministic Simulation Testing architecture: Antithesis deploys software as a controlled Linux target running at 48x parallelism by default, fast-forwarding sleep calls and injecting controlled nondeterminism. A 15-minute PR-level run simulates hours of real execution time, while overnight 12-hour runs can simulate roughly three months of software runtime for high-confidence regression coverage.
- •Unknown-unknown testing gap: Standard tests encode known behavior as regression anchors, leaving the most damaging bugs untested. DST instead breadth-first searches the full state space by branching timelines at any execution point, changing thread scheduling, randomness, or fault injection mid-simulation — reaching failure modes no human would think to specify in advance.
- •SQLite WAL bug reproduction benchmark: A concurrency bug present in SQLite for ten years, triggered only once in production at Tailscale, was reproduced by Antithesis in 15 minutes using a generic workload covering all SQLite operations with equal probability — no prior knowledge of the bug's location was required to find it.
- •Property-based verification over path-based tests: Instead of encoding specific execution sequences, define system-wide invariants — such as SQLite's built-in `PRAGMA integrity_check` — and instruct Antithesis to evaluate them at random simulation points. This prevents AI-generated code from overfitting to narrow test cases, forcing implementations toward genuinely correct general-purpose behavior.
- •AI coding shifts effort toward specification and verification: As AI compresses code-writing time, engineering effort should rebalance toward precise specifications that derive testable properties, and toward verification nets that validate all possible execution paths against those properties — not just the paths developers anticipated when writing the original feature.
Notable Moment
Carl describes a potential future where software engineering shifts from iterative development to a diffusion-like process — rewriting entire codebases from updated specifications and releasing the result directly, provided it passes a comprehensive simulation-based verification net covering the full state space.
Episode Transcript
Software testing is widely understood as essential to building reliable systems, and it's one of the hardest things to get right. A fundamental issue is that tests are good at confirming the behavior a team expects, but the most damaging failures tend to hide in the edge cases no one thought to check during development. Those blind spots are only growing as AI produces more code that no human has closely reviewed. Antithesis is a software verification company built around an approach called deterministic simulation testing. The platform runs a customer software in a fully controlled environment, exploring thousands of different paths through it at runtime. Crucially, the paths aren't prespecified, and they're not merely the expected cases. In this way, it can surface rare, damaging bugs that normal testing would never catch. Carl Spera is on the red team at Antithesis, and he also leads much of the company's AI strategy. In this episode, Carl joins Sean Falconer to discuss the Antithesis approach to software verification, why reliability tooling has been chronically underinvested, what makes stateful and distributed systems so hard to test, how deterministic simulation testing works under the hood, and much more. This episode is hosted by Sean Falconer. Check the show notes for more information on Sean's work and where to find him. Carl, welcome to the show. Hey, Sean. Happy to be here. Yeah, absolutely. So we're going to get into all kinds of stuff today, but I thought just to start things off, could you give people maybe a sense of like what you actually do day to day? It seems like you're embedded with customers. You're tracking the shape of defects as they hit. What is it your day to day kind of look like? That's a great question. So I work at Antithesis and Antithesis is a software verification company. Right? And what my job is on the paper is I'm on a team called the red team. And this is not to be confused with red teams in... Like, a lot of times, teams are, like, more like a security team, maybe, like, an internal, like, red teaming security team. In this case, we named the red team after the idea that what if we hired a bunch of distributed systems experts, people who had spent their whole careers working on building distributed systems and testing them? What if we gave them essentially unlimited access to Intithesis to become experts in how to use Intithesis as a testing technology and then basically use that team to then go and help our customers use the technology to its fullest. So I would say my core goal is to become an expert in antithesis and then help our customers solve and find these very hard bugs in distributed systems. I also am taking a lead in a lot of our AI strategy. So I sort of bridge the gap between a customer facing role and more of like a product role. Okay. And …
Get the full transcript (9,485 words) + summary by email — free
One-time email with the complete transcript and AI summary of this episode. No account needed.
One email, no spam. We’ll also show you what SignalCast does.
You just read a 3-minute summary of a 44-minute episode.
Get Software Engineering Daily summarized like this every Monday — plus up to 2 more podcasts, free.
Pick Your Podcasts — FreeKeep Reading
More from Software Engineering Daily
SED News: Jev, Meta’s Muse, and the AI Slowdown Paradox
Oct 13 · 49 min
Practical AI
Open models and the future of Physical AI with NVIDIA
Oct 1
More from Software Engineering Daily
Steve Jobs in Exile
Oct 8 · 122 min
Latent Space
🔬“We have foundation models for language, not for physics” — Anima Anandkumar, Bren Professor of Computing
Aug 26
More from Software Engineering Daily
We summarize every new episode. Want them in your inbox?
Similar Episodes
Related episodes from other podcasts
Practical AI
Oct 1
Open models and the future of Physical AI with NVIDIA
Latent Space
Aug 26
🔬“We have foundation models for language, not for physics” — Anima Anandkumar, Bren Professor of Computing
The Startup Ideas Podcast
Jan 19
Claude Code Clearly Explained (and how to use it)
Product School Podcast
Aug 27
Twilio CPO on Integrating AI into Product Strategy to Grow Revenue | Inbal Shani | E272
a16z Podcast
Oct 6
Building Defense for the Agentic Era: Kevin Mandia
Explore Related Topics
This podcast is featured in Best Cybersecurity Podcasts (2026) — ranked and reviewed with AI summaries.
Read this week's Health & Longevity Podcast Insights — cross-podcast analysis updated weekly.
You're clearly into Software Engineering Daily.
Every Monday, we deliver AI summaries of the latest episodes from Software Engineering Daily and 192+ other podcasts. Free for one show.
Start My Monday DigestNo credit card · Unsubscribe anytime