AI Summary
5 min read“Everybody hates waterfall.” That was one of Hillel Wayne’s key findings after interviewing 15–20 engineers across six or seven fields for his Crossover Project, which asked whether software engineers are really engineers. A former formal methods consultant who taught TLA+ across the industry, Hillel came into the project firmly believing software engineers were not engineers. He came out the other side convinced they probably are. The core tension, he found, is universal: how expensive a mistake is versus how quickly you can iterate. Civil engineers build scale models and use CAD to iterate on plans; electrical engineers smoke-test circuits; mining engineers had their own “agile revolution” in the 1960s with the New Austrian Tunneling Method. Software is just the best at iterating because we can press F11 and get results instantly.
What software engineering gets right (and wrong) compared to other fields
Continue reading the full summary in the app — free to try.
Read Full Summary →Free • No credit card required
Never miss an episode of The Pragmatic Engineer
Get every new episode summarized in your inbox — free, ~5 minutes to read.
No spam. Unsubscribe anytime.
What you'll learn
- 1 (00:09) **The Core Question: AI and Formal Verification** - The episode sets up the central tension: will AI-generated code make formal verification mainstream?
- 2 (02:28) **How Hillel Wayne Got Into Tech** - Hillel recounts his journey from physics student to Ruby on Rails developer, and how he fell into his current niche.
- 3 (03:40) **The Crossover Project: Are Software Engineers Real Engineers?** - Hillel describes his research project interviewing 15-20 engineers from various fields to answer this question.
- 4 (05:58) **Similarities Across Engineering Disciplines** - Key parallels between software and traditional engineering are explored, including a shared hatred for waterfall.
- 5 (07:46) **Differences: Where Software Excels and Lags** - The conversation contrasts the unique advantages of software engineering with the strengths of other fields.
- 6 (14:27) **What Software Can Learn From Other Engineers** - Hillel identifies two key areas where software engineering could improve by looking at traditional fields.
- 7 (16:23) **The Verdict: Are We Engineers?** - Hillel gives his final answer on the question that started the project, years later.
+ Full timestamped outline available in the app
Show Notes
Brought to You By:
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• WorkOS – everything you need to make your app enterprise ready.
—
There’s a popular theory that AI will finally make formal verification mainstream because mathematical proof of correctness will be needed when machines write most or all of the code. But will this happen? Today, I’m talking with one of the best people to tackle the prediction. Hillel Wayne is a formal methods consultant, educator, and author, who’s deeply interested in software history.
In this episode of Pragmatic Engineer podcast, I sit down with Hillel to compare software engineering with traditional engineering, discuss where formal methods fit into modern software development, and we explore why they are essential for some of the world's most complex systems. We cover the formal specification language, TLA+, walk through several formal verification tools, examine why distributed systems are so difficult to reason about, and look into whether AI will make formal methods accessible to more engineering teams.
—
Timestamps
00:00 Intro
03:21 The Crossover Project
10:26 What software engineering does better
14:19 What traditional engineering does better
17:06 Formal methods
28:21 TLA+: what it is and demo
35:47 TLA+ at Amazon
36:59 Ways distributed systems break
39:52 Formal methods and systems thinking
45:09 The value of learning math
49:12 What TLA+ is good for and isn’t
51:39 Alloy: a declarative language for software modeling
57:42 Other formal methods tools
1:00:13 Property-based testing
1:04:20 AI and the need for formal verification
1:11:18 Logic for programmers
1:13:24 Hillel’s 2025 prediction on AI’s impact
1:20:19 Book recommendation
—
The Pragmatic Engineer deepdives relevant for this episode:
More from this podcast
The Pragmatic Engineer →