Patrick Debois, who organised the first DevOpsDays in 2009 and is now an independent advisor and Product DevRel Lead at Tessl, joins Benedikt Stemmildt to look at software factories and dark factories through a DevOps lens.

Most factories automate the same loop of writing, reviewing and deploying code. Patrick argues that the harder question is when a change can reach customers without a human reviewing it, and that this is a question of risk rather than of code. From there, he explains why he turns whatever he can into deterministic checks, why a factory should explore as well as build, and how factories change the size of teams, the roles inside them and the way organisations share what they build.

In this episode:

• Why risk, not code, decides what a dark factory can ship on its own
• How architecture absorbs risk, and why dark factories come in gradations
• Deterministic checks, and why loose orchestrators turn into state machines
• Research loops and the idea of a dream factory
• Smaller teams, fused roles and why Patrick would not go below four people
• Factories as platforms, and why model upgrades are major upgrades
• Two metrics for a factory: human touches and reuse across the organisation

Chapters:

00:00 Intro
02:16 Software Factories Through a DevOps Lens
04:13 Risk Is the Real Merge Decision
06:52 Not Every Part of the Code Carries the Same Risk
11:15 Dark Factories Come in Gradations
12:23 Deterministic and Non-Deterministic Checks
14:06 Orchestrators vs. State Machines
17:04 Local Iteration vs. Autonomous Factories
19:12 Research Loops and the Dream Factory
21:32 Pipelines Beyond Code
22:46 Smaller Teams, Fused Roles
26:24 Solo Developers and the Bus Factor
28:29 System Thinkers and Chaos Engineers
31:40 Factories as Platforms
34:57 Model Upgrades Are Major Upgrades
37:36 What Happens to Juniors?
44:19 How Companies Should Start
46:23 Two Metrics: Human Touches and Reuse
47:52 From Solo to Multiplayer Factories
49:39 Deploying Skills, Installing Loops
51:10 Patrick's Advice
52:38 Wrap-Up

Mentioned in this episode:

• AI Native DevCon NYC, 2 to 4 November 2026: https://tessl.io/devcon
• AI Native Dev: https://ainativedev.io
• Tessl: https://tessl.io
• DevOpsDays: https://devopsdays.org
• Guest: Patrick Debois · https://jedi.be
• Host: Benedikt Stemmildt, founder of hackers&wizards
  

Rethink Engineering is powered by re:cinq and hackers&wizards.

All episodes: https://re-cinq.com/podcast

Sam Newman, author of Building Microservices and the new Building Resilient Distributed Systems, joins Benedikt Stemmildt to talk about resilience engineering now that AI writes more of our software and runs inside more of our products.

Resilience isn't about making sure nothing goes wrong. It's about making sure as many things go right as possible. From Google's Velcro-strapped servers to a network outage caused by rabbits eating cables, Sam explains why systems, and the people who run them, have to be built for surprise. Then he applies the same lens to AI: model providers that aren't yet cloud-grade, why automated remediation with AI is still a long way off, and why your software factory is a production system in its own right.

In this episode:

• Why resilience focuses on what goes right, not only on preventing failure
• David Woods' four concepts: robustness, rebound, graceful extensibility and sustained adaptability
• Why LLM providers aren't cloud-grade yet, and how to hedge across models and vendors
• Why AI can help during an incident, but can't fix it for you (yet)
• Why you can't one-shot a large-scale system, and the modular on-ramp to software factories
• Team Topologies vs. top-down AI mandates
• Ship fast enough to care: burnout, cognitive debt and Peter Naur's theory building

Chapters:
00:00 Intro
01:17 Sam's New Book on Resilient Distributed Systems
06:10 Making Sure Things Go Right
08:33 Why Failure Is a Numbers Game
11:31 Robustness and Rebound
13:20 LLM Providers Aren't Cloud-Grade Yet
16:04 Multi-Model, Multi-Vendor
19:45 Why AI Auto-Remediation Is a Long Way Off
24:10 Agent Retries vs. Production Retries
28:24 Building With AI vs. Building AI Into Products
30:04 Rabbits, Burning SSDs and the Unexpected
32:46 Sustained Adaptability and Psychological Safety
34:10 Is a Software Factory Resilient?
40:10 Dark Factories and the Modular On-Ramp
44:27 Teams, Not Top-Down AI Mandates
49:56 Ship Fast Enough to Care
52:15 Cognitive Debt and Theory Building
55:21 Don't Go All In
57:47 Wrap-Up

Mentioned in this episode:

• Building Resilient Distributed Systems: https://www.oreilly.com/library/view/building-resilient-distributed/9781098163532/
• Four Concepts for Resilience, David Woods: https://www.sciencedirect.com/science/article/abs/pii/S0951832015000848
• Cognitive debt, Margaret-Anne Storey: https://margaretstorey.com/blog/2026/02/09/cognitive-debt/

Guest: Sam Newman · https://samnewman.io
Host: Benedikt Stemmildt, founder of hackers&wizards

Rethink Engineering is powered by re:cinq and hackers&wizards.
All episodes: https://re-cinq.com/podcast

What happens when you actually run a software factory? Steve Yegge, creator of Gas Town and Beads, runs around 50 AI agents on his long-running online game, Wyvern. In this episode he talks with Benedikt Stemmildt about what that looks like day to day: the breakthroughs, the breakdowns, and what enterprises should learn from it before they try it themselves.

Last week Steve burned down 40% of his own software factory. His agents had added more than a hundred safety gates until nothing could move, and it took a newer model, acting like an outside consultant, to cut the system back to 14. Then, with the fences gone, the agents shipped 46 game features during a week when Steve had said "no game work".

A note for longtime listeners: Waves of Innovation is now Rethink Engineering. Same feed, new name, and a new host: Benedikt Stemmildt, founder of hackers&wizards, takes over from Deejay. The show is now powered by re:cinq and hackers&wizards. Thanks for listening, and welcome to the next chapter.

In this episode:

• Why agents need mechanical constraints (governors, quotas, pace gates, message budgets) instead of common sense
• The factory that will "never be done": how adversarial reviews and a growing backlog turn all work into more work
• Steve's rule: spend 40% of your effort on code quality, or end up spending 60%
• A look inside Wheelhouse, Steve's control room for his agent fleet, and the merge queue clearing 230+ commits a day
• Why faster engineering pushes the bottleneck downstream, onto reviewers, business teams and customers
• Why enterprise AI is arriving "upside down": production agents on ticket queues succeed straight away, while automating the build side struggles
• Why the place to start is one narrowly scoped production agent, and why outcomes, not outputs, are the new North Star

Mentioned in this episode:

• Welcome to Gas Town (Steve's post): https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04
• Gas Town: https://yegge.ai/gastown
• Welcome to Gas City: https://yegge.ai/essays/welcome-to-gas-city/
• Beads, the agent issue tracker: https://github.com/gastownhall/beads
• Dolt, the versioned database behind Beads: https://www.dolthub.com
• Wyvern, Steve's game: https://yegge.ai/wyvern
• Output to Outcome by Mik Kersten: https://outputtooutcome.org

Guest: Steve Yegge

Host: Benedikt Stemmildt, founder of hackers&wizards

Rethink Engineering, powered by re:cinq and hackers&wizards, is about how AI is changing the way software gets built. New episode every month.

WATCH THE FULL EPISODE HERE: https://re-cinq.com/podcast/steve-yegge-software-factory