A Mere Formality cover art

A Mere Formality

A Mere Formality

Written by: John Willis
Listen for free

A Mere Formality is a podcast about formal verification, software engineering, and the growing challenge of knowing whether the systems we build actually do what we think they do.

Hosted by John Willis and Ray Myers, the show digs into the ideas, people, research, and real-world applications behind formal verification, connecting theory with the everyday realities of building and operating software.

You don't need to be a mathematician or formal methods expert to follow along. A Mere Formality is about asking a deceptively simple question: How do we know our software is actually correct?


John's LinkedIn:
https://www.linkedin.com/in/johnwillisatlanta/


Ray's LinkedIn:

https://www.linkedin.com/in/cadrlife/

© 2026 A Mere Formality
Episodes
  • S1 E2 - Annie Vella - Proving What AI Builds

    S1 E2 - Annie Vella - Proving What AI Builds
    Oct 7 2026
    Ray and John have a conversation with Annie Vella in this episode about why formal verification, a discipline she first encountered more than twenty years ago, is suddenly becoming increasingly relevant in the age of AI-assisted software development.With a background spanning mathematics, computer science, software engineering, DevOps, and large-scale banking systems, Annie Vella first studied formal methods at university in the early 2000s. At the time, proving software correct mathematically was intellectually rewarding but difficult, expensive, and rarely practical in everyday software development. Today, better tooling and the rapid rise of AI-generated code are changing that equation.We explore a growing problem in software engineering: AI can generate code dramatically faster, but that simply moves the bottleneck downstream. If humans remain responsible for reviewing every generated line, the promised productivity gains become difficult to realize. Formal verification offers another possibility. Rather than manually inspecting everything an AI produces, can we mathematically verify the properties that actually matter?That leads us into the importance of specifications. Annie discusses the renewed interest in spec-driven development, the difference between lengthy natural-language requirements and genuinely formal specifications, and how tools such as Dafny, Verus, Lean, SMT solvers, and emerging AI-assisted approaches could make rigorous verification more accessible to everyday engineers.However, verifying AI-generated code is only part of the challenge. Agentic systems introduce an even deeper problem: agents can dynamically make decisions, invoke tools, generate code, and take actions at runtime. Annie offers a deceptively simple example that an agent instructed to delete duplicate files could technically satisfy that requirement by deleting every file. Correctness therefore depends not only on verifying an outcome, but on precisely defining what the system is and is not allowed to do.We also examine what this could mean for highly regulated environments such as banking. Formal methods may provide a way to define critical invariants, constrain dangerous agent behavior, and even help modernize legacy systems by formally capturing essential properties before replacing decades-old implementations.Ultimately, our conversation comes back to something deeper than tooling. Building trustworthy AI-enabled systems requires engineers to become better at defining what they actually mean by “correct.” Formal verification forces that clarity. As AI makes generating software increasingly cheap, the ability to specify, verify, and reason about what that software should do may become one of the most valuable engineering skills of all.Show Notes:Birgitta Böckeler and Laura Tacho on Spec Driven Developmenthttps://www.thoughtworks.com/insights/podcasts/technology-podcasts/what-is-spec-driven-developmentDeveloping provably correct Rust code with Verushttps://www.amazon.science/blog/developing-provably-correct-rust-code-with-verusDafnyhttps://dafny.org/LemmaScripthttps://lemmascript.org/Guardians of the Agents: Formal verification of AI workflows by Erik Meijerhttps://dl.acm.org/doi/10.1145/3777544Fermat's Last Theorem, Xena project commentary on Anthropic's proofhttps://xenaproject.wordpress.com/2026/09/04/flt-anthropic-has-beaten-me-to-it/Easy Approach to Requirements Syntax (EARS)https://en.wikipedia.org/wiki/Easy_Approach_to_Requirements_Syntaxhttps://kiro.dev/blog/deep-spec-analysis/https://www.amazon.science/blog/developing-provably-correct-rust-code-with-verushttps://cdn.amazon.science/bb/40/22ac44f84f6d8eb625ac9666a00f/formally-verified-cloud-scale-authorization.pdfhttps://midspiral.comhttps://dl.acm.org/doi/pdf/10.1145/3815784https://dl.acm.org/doi/10.1145/3777544https://kiro.dev/docs/specs/feature-specs/https://dl.acm.org/doi/abs/10.1145/3815784
    Show More Show Less
    58 mins
  • S1 E1 - A Mere Formality - John Willis and Ray Myers

    S1 E1 - A Mere Formality - John Willis and Ray Myers
    Sep 11 2026

    In this inaugural episode, John Willis and Ray Myers sit down to launch A Mere Formality, a new conversation exploring formal methods, software verification, and the search for certainty in an increasingly AI-driven world. Ray introduces formal methods as a family of techniques for applying mathematical rigor to software, an area he believes is poised for renewed importance as AI coding agents become more autonomous.


    First, John and Ray trace the path that brought them to this topic, from the rise of generative AI and coding agents to growing concerns about uncertainty, evaluation, containment, and risk. If an AI agent can not only generate code but also make decisions and take actions, how do we establish confidence that the resulting systems will behave as intended? Their discussion positions formal methods as a potential bridge between the nondeterministic nature of AI and the deterministic assurances required in consequential software systems.


    Then, Ray breaks down the distinction between formal methods, formal specification, and formal verification, explaining how specifications can allow teams to reason rigorously about a system's design before, or alongside, its implementation. They explore tools such as TLA+, Quint, and Lean, including how formal specifications can uncover race conditions and unexpected behaviors in distributed systems that conventional prose or Markdown specifications may miss.


    The conversation also looks at the history of formal methods in high-consequence environments, from aerospace and medical systems to cloud providers such as Amazon. John draws a parallel with technologies like cloud computing and containers: capabilities once reserved for technology giants can eventually become accessible to everyone. Could formal verification be approaching its own “Docker moment,” where previously specialized techniques become practical for mainstream software development?


    Finally, John and Ray examine the relationship between AI and mathematical proof. Rather than viewing AI as a replacement for rigor, they discuss the potential power of combining LLMs with theorem provers such as Lean, using AI to explore solutions while formal systems provide a mechanism for checking them. That combination could become increasingly important as organizations deploy autonomous agents in high-consequence environments such as banking and financial services.


    The episode sets the direction for A Mere Formality: exploring how formal methods can move beyond their academic and specialized roots to help us build, evaluate, and trust the next generation of software. As AI accelerates our ability to create code, the bigger question may be how we create certainty at the same speed.
    Show More Show Less
    38 mins
adbl_web_anon_alc_button_suppression_t1
No reviews yet