Skip to main content
Software Engineering Daily

Software Verification in the Age of Coding Agents

47 min episode · 2 min read
·
Carl Spera

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.

Know someone who'd find this useful?

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.

Browse all Software Engineering Daily transcripts →

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 — Free

Keep Reading

More from Software Engineering Daily

We summarize every new episode. Want them in your inbox?

Similar Episodes

Related episodes from other podcasts

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 Digest

No credit card · Unsubscribe anytime