Hard Boiled Software

"Event Modeling: The Blueprint for Building Maintainable Software" with Adam Dymitruk

Adam Dymitruk is the creator of event modeling and the CEO and founder of Adaptech Group [https://adaptechgroup.com/], a consultancy that builds information systems using event sourcing and event modeling. A software developer with over three decades of experience, Adam is a core contributor to CQRS and event sourcing theory and practice since 2008, a top 0.1% Stack Overflow contributor, and one of the original voices in the ALT.NET movement. He’s currently writing the definitive book on event modeling, with a companion booklet due out first. Episode Description Why do we keep building software that breaks every time we add a feature? And what if there were a way to describe a system so clearly that business people, designers, and developers could all work from the same blueprint? In this conversation, Adam Dymitruk traces a path from the rebellion of the ALT.NET movement in the mid-2000s through the rise of domain-driven design, the discovery of event sourcing, and the creation of event modeling, a notation and process for describing information systems that has quietly become one of the most practical innovations in modern software design. Along the way, Adam and Dave revisit shared history: the nHibernate Mafia, the fight against sealed classes, the moment when Martin Fowler’s 2005 article on event sourcing planted a seed that would take years to fully grow, and the community of developers who decided they’d rather take care of each other than wait for permission from Microsoft. The heart of the episode is Adam’s case for why event sourcing and event modeling eliminate entire categories of problems that most teams accept as inevitable: the hockey-stick cost curve, the coupling that turns codebases into houses of cards, the schema migrations that become existential crises, and the tech debt that accumulates because every new feature has to touch code that already works. Adam explains how Adaptech Group has built its business on fixed-cost contracts and free bug fixes, not as a loss leader but because the architecture genuinely makes it possible. The conversation closes with Adam’s view on AI as the next irreversible point of no return, why event modeling provides exactly the kind of specification that AI needs to generate good code, and a first look at the two books he’s writing to bring this work to a wider audience. Links & Resources Guest Links * Adaptech Group [https://adaptechgroup.com/] — Adam’s consultancy * Event Modeling [https://eventmodeling.org/] — the official site for the event modeling methodology * Event Modeling: What is it? [https://eventmodeling.org/posts/what-is-event-modeling/] — Adam’s original 2019 article * Adam Dymitruk on LinkedIn [https://www.linkedin.com/in/eventmodeling/] * Adam Dymitruk on GitHub [https://github.com/adymitruk] * Event Modeling Discord Community [https://discord.com/invite/Sw4MvagftJ] Books & Articles Mentioned * Understanding Eventsourcing [https://leanpub.com/eventmodeling-and-eventsourcing] by Martin Dilger — the first book combining event modeling and event sourcing * Domain-Driven Design [https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215] by Eric Evans — the influential “blue book” both Adam and Dave reference on multiple occasions * Domain-Driven Design Reference [https://www.domainlanguage.com/ddd/reference/] by Eric Evans — the companion booklet that Adam credits as a model for his own booklet approach * Working Effectively with Legacy Code [https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052] by Michael Feathers — cited by Adam as a model for the reference-pattern format of his upcoming book * “Event Sourcing” [https://martinfowler.com/eaaDev/EventSourcing.html] by Martin Fowler — the December 2005 article that introduced Adam to event sourcing Tools, Frameworks & Concepts * Event Sourcing [https://martinfowler.com/eaaDev/EventSourcing.html] — an architectural pattern of storing state changes as an immutable sequence of events * CQRS [https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs] (Command Query Responsibility Segregation) — a pattern for separating read and write models * Domain-Driven Design [https://www.domainlanguage.com/] — Eric Evans’ approach to software development that became the intellectual home for event sourcing in the .NET world * Event Storming [https://www.eventstorming.com/] — Alberto Brandolini’s workshop format that influenced event modeling’s collaborative approach * ALT.NET [https://www.hanselman.com/blog/hanselminutes-podcast-104-dave-laribee-on-altnet]— the mid-2000s .NET developer community that championed open source, TDD, and better practices * Test-Driven Development [https://en.wikipedia.org/wiki/Test-driven_development] (TDD) — discussed at length, including Adam’s controversial position that event sourcing eliminates the need for it * Cucumber [https://cucumber.io/] — BDD testing tool that Adam used before discovering that events themselves serve as specifications * Storyteller [https://github.com/storyteller/storyteller] — Jeremy Miller’s graphical DSL testing framework for .NET that Adam used extensively for specification by example * NUnit [https://nunit.org/] — Charlie Poole’s open source .NET testing framework, a counterpart to Java’s JUnit * nHibernate [https://nhibernate.info/] — the open source .NET ORM ported from Java’s Hibernate; central to ALT.NET’s origin story (originally nicknamed the “nHibernate Mafia”) * Dynamic Consistency Boundary [https://javapro.io/2025/10/28/dynamic-consistency-boundaries/] — an evolution beyond DDD aggregates for managing consistency in event-sourced systems * Specification by Example [https://www.amazon.com/Specification-Example-Successful-Deliver-Software/dp/1617290084] / Behavior-Driven Development [https://dannorth.net/blog/introducing-bdd/] — the testing and specification approaches that preceded event modeling * Open/Closed Principle [https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle] — referenced by Adam in the context of event sourcing’s add-only architecture * Cursor [https://www.cursor.com/] — AI coding tool Adam used to demonstrate that event model screenshots produce correct implementations on the first try * Unix Philosophy — invoked by Dave to describe the component architecture that event sourcing enables: many specific tools that each do one thing well People Referenced * Greg Young [https://www.eventstore.com/] — CQRS and event sourcing pioneer, longtime collaborator * Scott Bellware [https://eventide-project.org/] — Founder of the Eventide project and co-founder of ALT.NET * Martin Fowler [https://martinfowler.com/] — author of the 2005 event sourcing article * Eric Evans [https://www.domainlanguage.com/] — author of Domain-Driven Design * Michael Feathers [https://michaelfeathers.silvrback.com/] — author of Working Effectively with Legacy Code (also former podcast guest [https://newsletter.nerdnoir.com/p/hbs-001-michael-feathers]) * Alberto Brandolini [https://www.eventstorming.com/] — creator of Event Storming * Martin Dilger [https://www.linkedin.com/in/martindilger/] — author of Understanding Eventsourcing * Jeremy Miller [https://jeremydmiller.com/] — creator of the Storyteller testing framework * Mike Stockdale — creator of SpecSharp, from Calgary * Charlie Poole [https://github.com/CharliePoole] — creator of NUnit * Sebastian Lambla [https://serialseb.com/] — .NET open source contributor whose work was famously overwritten by Microsoft * Scott Hanselman [https://www.hanselman.com/] — referenced in the context of ALT.NET’s reach into the Microsoft community Topics Discussed The ALT.NET Rebellion and Finding Your People Adam and Dave open by tracing their shared history in the ALT.NET movement, a community of .NET developers who pushed back against Microsoft’s top-down approach to software development in the mid-2000s. What started as frustration with sealed classes, proprietary tooling, and the “embrace, extend, extinguish” mentality became a proving ground for open source, test-driven development, and the architectural ideas that would shape both of their careers. Key points: * ALT.NET (originally nicknamed the “nHibernate Mafia”) was born from developers needing to take care of each other because Microsoft wasn’t supporting the open source community * The community brought together TDD practitioners, open source advocates, and domain-driven design enthusiasts, creating the conditions for ideas like event sourcing to gain traction * Figures like Sebastian Lambla experienced the worst of Microsoft’s competitive stance, having their open source work overwritten overnight by official Microsoft alternatives * Both Adam and Dave credit ALT.NET as the environment where their points of view coalesced, particularly around DDD and event-driven architectures From Domain-Driven Design to Event Sourcing The conversation traces how DDD provided the intellectual soil for event sourcing to take root, beginning with Martin Fowler’s 2005 article and evolving through Adam’s own experiments writing his first event store in 2009. Adam describes the shift from thinking about domain models and objects to thinking about state changes, facts, and immutable ledgers. Key points: * Adam wrote his first production event store in 2009 as a single page of C# code, proving the simplicity of the approach * The key insight: treat information the way accountants treat money, with full accountability and no erasures * Specification by example and BDD, while valuable stepping stones, became unnecessary once events themselves served as human-readable specifications * The community continues to evolve; practices like dynamic consistency boundaries are replacing traditional DDD aggregates, and event versioning through upcasters is giving way to handling multiple event versions directly in read models Event Modeling: The Swiss Army Knife Adam delivers his pitch for event modeling: a notation and process for describing information systems that looks like a sideways storyboard, captures state changes as events in plain English, and deliberately excludes implementation details. Born from the realization that his team at Adaptech was already doing something distinctive (they just thought they were doing BDD really well), event modeling was first formally written down at the Event Storming summit in 2018. Key points: * Event modeling uses only three moving pieces and four patterns based on two ideas; it takes minutes to explain and the rest is learned in practice * No branching logic in workflows; the notation sticks to a storyline by example because human minds remember stories far better than they remember graphs * The UX/UI is a first-class citizen in an event model, not an afterthought, because every system is ultimately built for human beings looking at an interface * Event modeling functions as a blueprint comparable to architectural plans for a building: the plumber, the carpenter, and the electrician all work from the same document The Flat Cost Curve and Why Coupling Is the Real Enemy Adam makes a direct business case for event sourcing and event modeling: Adaptech Group offers fixed-cost contracts and fixes bugs for free. This isn’t charity; it’s a direct consequence of an architecture where new features don’t touch existing code, coupling is managed by design, and the immutable event ledger serves as the single source of truth. Key points: * The “hockey stick” cost curve in traditional software comes from coupling: shared canonical models, CRUD operations that affect multiple consumers, and abstractions that break everything when they change * Event sourcing inverts this by using multiple purpose-built read models that each have exactly what they need, coordinated by an undisputed set of events * Schema migrations effectively disappear because new versions of data and old versions coexist naturally * The biggest conceptual barrier is the industry’s attachment to a single canonical model, an idea sold from academia through inheritance hierarchies that doesn’t mirror how real-world information systems have operated for centuries AI as the Next Point of No Return The conversation turns to AI, which Adam frames alongside the Commodore 64, the internet, email, Linux, and event sourcing itself as an irreversible “aha moment.” His own turning point was watching ChatGPT generate CSS animations in seconds that would have taken him three hours, and he sees event modeling as the missing link that gives AI the specification quality it needs to generate real systems. Key points: * AI’s impact is comparable to how Google gave us access to everything, but AI gives us the ability to make sense of everything instantly * The bottleneck is shifting left to planning, which is exactly where event modeling lives: providing clear, structured specifications that AI can execute against * Adam demonstrated early success pasting event model screenshots into Cursor’s chat window and getting correct unit tests and implementations on the first try, even with less capable models * The Pandora’s box framing: you can’t uninvent the internet, and you can’t uninvent AI inference; the question is whether your specifications are good enough to benefit from it Two Books and What’s Next Adam closes with an update on his long-anticipated event modeling book, which is actually two books. Inspired by Eric Evans’ companion booklet to the DDD blue book and Michael Feathers’ reference-pattern format in Working Effectively with Legacy Code, Adam is releasing a concise booklet first, followed by a comprehensive reference book. Key points: * The booklet comes first, designed to be immediately applicable, covering why event modeling exists, its core pieces, and the rules for assembling them * The full book will include the backstory and motivations, plus a library of reference patterns covering the top 90% of common information system scenarios (sign-up flows, payment integrations, checkout carts, pub/sub patterns, and more) * Adam deliberately delayed the book because he never wanted event modeling to require a book to understand, a lesson drawn directly from watching the DDD book’s intimidating thickness reduce its effective adoption * Martin Dilger’s Understanding Eventsourcing already covers event sourcing using event modeling throughout, giving the community a practical resource while the definitive event modeling book takes shape Hard Boiled Software is hosted by Dave Laribee. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com [https://newsletter.nerdnoir.com?utm_medium=podcast&utm_campaign=CTA_1]

"Whole Team, One Mission" with Woody Zuill

Woody Zuill is the leading advocate of mob programming, now called software teaming, an approach in which the whole team works together on the same thing at the same time on the same computer. A software developer for over 40 years, Woody is the co-author of Software Teaming: A Mob Programming, Whole-Team Approach (with Kevin Meadows) and a globally recognized speaker, trainer, and coach who has delivered workshops on every continent except Antarctica. He’s also an instigator behind the #NoEstimates discussion and a lifelong student of what makes teams actually work. Episode Description What happens when you put the whole team at one keyboard and keep them there? In this wide-ranging conversation, Woody Zuill traces the path from his earliest experiments with pair programming in the late 1990s through the accidental discovery of mob programming at Hunter Industries to his current thinking on software teaming, AI, and the art of storytelling. Along the way, he reveals how a children’s book illustrator, a musical instrument factory, and a very specific kind of stubbornness about teamwork shaped one of the most distinctive practices in modern software development. Woody shares the origin story of mob programming with refreshing honesty: how the name was borrowed from someone else’s article, how the practice emerged from simply not wanting to stop working together, and how his early struggles with public speaking led to a decades-long commitment to iterating on the same talks until they shine. The conversation moves through the concept of Team Flow (and why it validated what Woody’s teams were already experiencing), how different teams around the world have adapted software teaming to fit their own rhythms, and why the question “how can five people at one computer be productive?” might be the wrong question entirely. Whether you’re curious about what mob programming actually looks like in practice, wondering whether AI changes the case for working together, or just want to hear why Woody thinks we’ll stop writing code in programming languages altogether someday, this episode delivers the kind of hard-won, experience-tested insight that only comes from someone who’s been doing the work, and paying attention, for four decades. Links & Resources Guest Links * Woody Zuill’s Website [https://woodyzuill.com/] * Woody Zuill on LinkedIn [https://www.linkedin.com/in/woodyzuill] * Software Teaming: A Mob Programming, Whole-Team Approach [https://www.amazon.com/Software-Teaming-Programming-Whole-Team-Approach/dp/B0BLG1QTYK] by Woody Zuill & Kevin Meadows Books & Articles Mentioned * Teaming: How Organizations Learn, Innovate, and Compete in the Knowledge Economy [https://www.amazon.com/Teaming-Organizations-Innovate-Compete-Knowledge/dp/078797093X] by Amy Edmondson — the book that made Woody wish he’d called it “teaming” from the start * Extreme Programming Perspectives [https://www.amazon.com/Extreme-Programming-Perspectives-Michele-Marchesi/dp/0201770059] — edited collection containing the original “Mob Programming” article by ThoughtWorks practitioners * Pair Programming Illuminated [https://www.amazon.com/Pair-Programming-Illuminated-Laurie-Williams/dp/0201745763] — early book on pair programming that influenced Llewellyn Falco’s thinking * Team Flow: The Psychology of Optimal Collaboration [https://www.amazon.com/Team-Flow-psychology-collaboration-SpringerBriefs-ebook/dp/B07Y1N7X8M] by Jef van den Hout & Orin C. Davis — research on achieving shared psychological flow in teams * “Big Ball of Mud” [https://www.laputan.org/mud/] by Brian Foote & Joseph Yoder — the classic 1997 paper on the most common software architecture pattern Tools, Frameworks & Concepts * Software Teaming / Mob Programming [https://woodyzuill.com/home/software-teaming-mob-programming/] — a whole-team approach to software development at one computer * Strong-Style Pairing [http://llewellynfalco.blogspot.com/2014/06/llewellyns-strong-style-pairing.html] — Llewellyn Falco’s driver-navigator technique: “For an idea to go from your head into the computer, it must go through someone else’s hands.” * FAST Agile [https://www.fastagile.io/] — Fluid Adaptive Scaling Technology, developed by Ron Quartel, is closely related to software teaming * #NoEstimates [https://holub.com/noestimates-an-introduction/] — discussion and movement around rethinking estimation in software, originated by Woody * Driver-Navigator Pattern — the foundational collaboration technique for pair and mob programming * Team Flow [https://www.amazon.com/Team-Flow-psychology-collaboration-SpringerBriefs-ebook/dp/B07Y1N7X8M] — research concept from Jef van den Hout on achieving collective psychological flow in teams People Referenced * Llewellyn Falco [https://www.linkedin.com/in/llewellynfalco/] — inventor of Strong-Style Navigation, creator of ApprovalTests, recommended by Woody for an interview * Amy Edmondson [https://www.hbs.edu/faculty/Pages/profile.aspx?facId=6451] — Harvard professor, author of Teaming * Linda Rising [https://lindarising.org/] — speaker and author who advised Woody early on to tell stories in presentations * Ken Schwaber [https://www.scrum.org/] — Scrum co-creator; Woody trained with him at the 2007 Scrum Gathering in Portland * Ron Quartel — creator of the FAST framework and experimented with dynamic teaming in Seattle * Jef van den Hout [https://flowconcepts.nl/en/] — Dutch researcher at Eindhoven University of Technology, developed the Team Flow model * Mihaly Csikszentmihalyi [https://en.wikipedia.org/wiki/Mihaly_Csikszentmihalyi] — psychologist who originated the concept of psychological flow * James Herr [https://www.linkedin.com/in/james-herr-63b85b1b3/] — Woody’s collaborator on talks about mob programming and AI * Fred Zuill [https://www.linkedin.com/in/fredzuill/] — Woody’s brother, who described AI as “a rather faulty, somewhat moderately skilled collaboration partner.” * Andrea Zuill [https://www.andreazuill.org/] — Woody’s wife, children’s book author and illustrator (Wolf Camp, Sweety, Dog vs. Strawberry, and others) * Kevin Meadows [https://www.linkedin.com/in/jkmeadows/] — co-author of Software Teaming * Brian Foote [https://www.laputan.org/mud/] & Joseph Yoder [https://www.joeyoder.com/] — authors of the “Big Ball of Mud” paper * Taiichi Ohno [https://en.wikipedia.org/wiki/Taiichi_Ohno] — Toyota Production System pioneer (referenced by Dave) Topics Discussed The Art of Iterating on a Talk Woody opens up about his journey from someone who couldn’t speak in front of five people to a presenter who has addressed audiences of over a thousand. His approach—repeating the same talk title while continually refining the content—runs counter to the conference circuit norm of always delivering something new, but mirrors the iterative principles at the heart of Agile itself. Key points: * Early advice from fellow speakers (including Linda Rising) shaped his approach: speak about what you know deeply, tell stories, and start with friendly audiences * His wife Andrea’s illustrations became a signature element of his presentations, helping audiences connect emotionally even before absorbing the content * The process of noting audience questions after every talk and incorporating answers into future versions created a natural feedback loop spanning years From Pair Programming to Software Teaming The origin story of mob programming traces back through Woody’s pair programming experiments in the late 1990s, an article in Extreme Programming Perspectives, and a series of increasingly larger team experiments that culminated at Hunter Industries around 2011-2012. The naming journey—from mob programming to software teaming—reflects both practical concerns and a deeper philosophical shift. Key points: * The “mob programming” name came from an article in Extreme Programming Perspectives (circa 2001-2002) by ThoughtWorks practitioners who experimented with groups larger than pairs * Woody dropped “programming” because it excluded testers, product people, and designers; he dropped “mob” because it means “bullying” in some European languages * Amy Edmondson’s Teaming (2012) captured what Woody was already seeing: the ability to work effectively as a team at any moment, not just being assigned to one * The real insight wasn’t a method—it was noticing that software teams never actually worked like teams in other industries (construction crews, bands, sign installation teams) Team Flow and the Prerequisites for Great Teamwork Woody connects his team’s experience at Hunter Industries to Jef van den Hout’s research on Team Flow at Eindhoven University of Technology. The academic framework validated what Woody’s teams had felt intuitively—and gave language to the conditions that make it possible. Key points: * Team Flow requires collective ambition (shared life values), a common goal (the work itself), personal goal alignment, high skill integration, open communication, and mutual commitment * The rock band analogy: shared ambition to be a band, common goal of the music, and personal goals that complement rather than compete (you don’t put six bass players in a group) * Once these conditions are met, continuous improvement happens naturally — you don’t need to impose it through retrospectives or process mandates * Woody reads extensively but approaches research skeptically; Team Flow resonated because it matched his direct experience Variations in Practice Around the World Having conducted workshops on every continent except Antarctica, Woody has observed that people everywhere respond similarly to working as a real team—but the specific practices vary widely. Three teams at one San Francisco company each found completely different approaches to the same core idea. Key points: * One team used timers, one switched drivers on request (”I don’t want to type anymore”), and a third kept one driver until a discrete task was complete—all valid * Cultural differences exist (some cultures discourage challenging your boss, others expect it), but Woody encourages teams to speak their native language while coding for clearer thinking * Woody never intended his starting guidelines to become rules; like Ken Schwaber told his 2007 Scrum class, the framework is a starting spot, not a destination * Ron Quartel’s FAST framework represents a compelling variation: dynamic reteaming every few days based on what the work demands AI, Learning Debt, and the Enduring Value of Working Together The conversation turns to AI with both curiosity and caution. Woody sees clear parallels between the navigator role in software teaming and prompting an AI — but warns that speed without understanding creates its own set of problems. Key points: * The navigator/driver separation in mob programming was essentially prompting before prompting existed: staying at the higher abstraction level while someone (or something) handles the details * Fred Zuill’s description of AI as “a rather faulty, somewhat moderately skilled collaboration partner” captures the current state well * Dave introduces the concept of “learning debt” — when AI generates code using models, libraries, and constructs that the developer doesn’t understand, creating a new and dangerous form of technical debt * Woody references the “Big Ball of Mud” pattern: AI-generated code risks producing an instant version of the architectural mess that normally takes years to develop * The deeper concern: teams may be getting more done, but not more of the right things done — echoing a pattern Woody has seen throughout his career Storytelling as the Next Frontier The episode closes with Woody’s emerging interest in storytelling workshops, inspired by watching his wife Andrea’s process as a children’s book illustrator. Her approach—drawing a character thousands of times until it becomes a living thing—mirrors the kind of deep, iterative practice that has defined Woody’s own career. Key points: * Andrea Zuill’s path from selling prints on Etsy to publishing children’s books began when people kept asking, “What book is that picture from?” — demand preceded supply * Woody sees storytelling as a natural extension of his work: conference talks depend on stories, and many practitioners want to develop this skill * Dave suggests product management as a particularly promising audience for storytelling workshops—great product managers tell stories that bring people on board with vision and customer pain * Woody’s honest reflection on his career’s current inflection point: demand for traditional Agile training is declining, and he’s exploring what comes next while staying true to what he cares about Hard Boiled Software is hosted by Dave Laribee [https://www.linkedin.com/in/laribee/]. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com [https://newsletter.nerdnoir.com?utm_medium=podcast&utm_campaign=CTA_1]

"The Missing Layer Between AI and Better Decisions" with Steve Elliott

Connecting the Dots from Strategy to Execution Steve Elliott [https://www.linkedin.com/in/steve-j-elliott/] is the founder and CEO of Dotwork [https://dotwork.com/], an AI-native strategic alignment platform built on knowledge graphs and flexible ontologies. A serial entrepreneur with several successful exits, Steve previously founded AgileCraft (acquired by Atlassian in 2019) and served as Head of Product at Atlassian. He also co-founded The Uncertainty Project [https://www.theuncertaintyproject.org/], a community-driven playbook for better organizational decision-making, and is the author of The Decisive Company [https://www.amazon.com/Decisive-Company-High-Performance-Organizations-Execution-ebook/dp/B0DNKPXG92/ref=sr_1_1?crid=3DS81JVUAPJMB&dib=eyJ2IjoiMSJ9.uN_Bn-lywgyu6uPjBC6rFD2rwWQbrn7M2yxYT8E7nTlmVZKhxdvvTgKAnZe3-8V6rrm1oon0Gm_ehEkA0NWGMfjfxB-vsbystnYKvCpT2EZki3wf2K-gNQoR15QIhnL2um90GP1jRWGVlphudPsmt4FfSWjZ3jLl4KAzEyvK1us3DiYDOdmP6teBvbWZbgiuUM536T_mhuIr6qhrZnJ5GDoN8guzoOJuD1klcxHuxyA.GBcxb3mrkHY_g8zaBvfWCbFaWt4EQ20KUl-bpPHKUaA&dib_tag=se&keywords=The+Decisive+Company&qid=1771091820&sprefix=the+decisive+company%2Caps%2C236&sr=8-1]. Episode Overview Why do so many organizations still run strategy on spreadsheets and slide decks? And what would it look like if AI could actually understand how your organization thinks—not just summarize its documents? In this conversation, Steve Elliott traces his path from Big Six consulting through serial entrepreneurship to the problem that’s consumed his career: strategic alignment in large, complex organizations. He unpacks why the gap between executive intent and team execution persists despite decades of tooling, and why the first generation of enterprise agility platforms—including the one he built and sold to Atlassian—ultimately couldn’t solve it. The root issue, Steve argues, isn’t cultural or procedural. It’s structural: organizations lack a durable, evolving memory of how they operate and why they make decisions. That diagnosis led Steve to build Dotwork, a platform that combines flexible ontologies, knowledge graphs, and AI to create what he calls an organizational operating system—one that can observe how work actually flows (not just how it’s drawn on slides), maintain context across planning cycles, and surface signals to leaders without drowning them in noise. Along the way, the conversation covers why operating models aren’t operating systems, how to make decisions under uncertainty, and what it would take for AI to move beyond task-level productivity to genuine systemic intelligence. Guest Links * Dotwork [https://dotwork.com/] — AI-native strategy and portfolio platform * Steve Elliott on LinkedIn [https://www.linkedin.com/in/steve-j-elliott/] * The Decisive Company: How High-Performance Organizations Connect Strategy to Execution [https://www.amazon.com/Decisive-Company-High-Performance-Organizations-Execution/dp/1544546432] by Steve Elliott Tools, Frameworks & Concepts * The Uncertainty Project [https://www.theuncertaintyproject.org/] — a community-driven playbook of decision-making models and techniques, co-founded by Steve * Knowledge Graphs — graph-based data structures for relating organizational concepts over time * Flexible Ontologies — adaptive data models that capture how an organization thinks and evolves * One-Way Door / Two-Way Door Decisions [https://www.youtube.com/watch?v=XjShSJkffzI] — framework for calibrating decision speed to reversibility * John Boyd’s OODA Loop [https://en.wikipedia.org/wiki/OODA_loop] — Observe, Orient, Decide, Act decision-making framework * Team Topologies [https://teamtopologies.com/] — framework for organizing teams around cognitive load and flow (referenced by Dave) * Product Operating Model [https://www.svpg.com/the-product-operating-model-an-introduction/] — outcome-oriented approach to organizing product development work * Event Sourcing [https://martinfowler.com/eaaDev/EventSourcing.html] https://martinfowler.com/eaaDev/EventSourcing.html— a software architecture pattern where system state derives from an audit trail of events (referenced by Dave) People Referenced * John Cutler [https://www.linkedin.com/in/johnpcutler/] — Head of Product at Dotwork, author of The Beautiful Mess [https://cutlefish.substack.com/] newsletter * W. Edwards Deming [https://en.wikipedia.org/wiki/W._Edwards_Deming] — management theorist, referenced by Dave (”by what method”) * John Boyd [https://en.wikipedia.org/wiki/John_Boyd_(military_strategist)] — military strategist, creator of the OODA loop Topics Discussed From Consulting to Serial Entrepreneurship Steve’s career began at one of the Big Six consulting firms, where the rapid rotation through large organizations gave him a front-row seat to recurring patterns of organizational dysfunction. Working on segregation of duties in ERP systems, he kept seeing the same problems resurface year after year—and realized that issuing reports wasn’t solving anything. That frustration drove him to build software that could address these problems. Key points: * Consulting provided breadth—seeing dozens of companies’ decision-making patterns in quick succession—but delivering reports felt hollow when the same issues reappeared annually * The pivot from consulting to software was driven by wanting to help customers actually solve problems, not just document them * This pattern of seeing recurring organizational dysfunction became the throughline across multiple startups The Strategic Alignment Problem The core problem Steve keeps chasing: in large organizations, executives have strategies and teams have plans, but the connection between them is fragile and constantly breaking. Plans go stale within weeks of creation, and the people tasked with keeping everything connected—what Steve calls “human glue”—can’t scale to keep pace with organizational complexity. Key points: * Leaders can’t see what’s working in real time; teams don’t understand why their priorities keep shifting * John Cutler’s framing of “forever problems”—alignment will never be fully solved, but getting meaningfully better at it changes everything * It’s often mislabeled as a culture problem when it’s actually a visibility and structural problem * The faster organizations move (flatter structures, AI adoption, tool proliferation), the harder alignment gets The Limits of Existing Tools Steve offers an honest postmortem on both ends of the tooling spectrum: scrappy spreadsheet-and-slides approaches that lose memory every planning cycle, and the first generation of enterprise agility platforms that assumed too much organizational consistency. Both fail for related but different reasons. Key points: * Spreadsheets and slides are cheap but create no organizational memory—every planning cycle feels like starting from scratch * Enterprise agility tools scaled process well but couldn’t scale understanding because their data models were too rigid * The fatal flaw of first-generation platforms: assuming conformity across the organization when real orgs are dynamic and constantly reshaping themselves * Steve built and sold one of these platforms (AgileCraft to Atlassian) and learned firsthand where the approach breaks down Ontologies, Knowledge Graphs, and Organizational Memory The technical heart of the conversation: Steve explains how flexible ontologies and knowledge graphs provide the foundation for a system that models how an organization operates—and evolves that model as the organization changes. The key concept is “durable context”—understanding not just what decision was made, but also what the world looked like when it was made. Key points: * An ontology is a shared language for how the organization thinks; a knowledge graph keeps those ideas connected over time * First-generation tools had their ontology hard-coded into a relational database—if the org didn’t match the model, the tool broke * Durable context means preserving the factors that surrounded a decision so you can compare past and present conditions meaningfully * Graph technology handles the networked nature of modern work while still supporting the hierarchies that matter (people, budgets, time) Operating Models vs. Operating Systems A subtle but important distinction: the operating model is the idealized version of how work should flow; the operating system is what’s actually happening on the ground. Steve argues that most organizations focus on the model and neglect the system—missing opportunities to learn from how work actually moves. Key points: * Operating models are like class diagrams; operating systems are like runtime behavior with observability * The gap between model and system is where the most valuable coaching and organizational design insights live * If teams are getting better outcomes by working outside the prescribed model, that’s a signal to update the model—not enforce compliance * Being able to observe both and compare them is a genuinely new organizational capability Dotwork’s Vision: Intelligence Without More Dashboards Dotwork’s approach is deliberately different from the “log into our dashboard” paradigm. Steve describes a vision of a “dark system”—a context engine with organizational memory that surfaces relevant signals to leaders wherever they already work, without requiring them to learn yet another tool. Key points: * Rather than pulling all data into one system via heavy connectors, Dotwork uses AI to progressively retrieve just the specific metrics and signals that matter * The goal is to eliminate status meetings and planning overhead by making alignment observable and continuous * The vision: an AI that knows both you (like a personal GPT) and your organization, enabling higher-value work * Leaders consistently ask for the same thing: help me look around corners and see second-order impacts before they become expensive mistakes AI Beyond Task-Level Productivity The conversation closes with a broader look at where AI creates systemic value versus task-level value. Steve argues that the bottleneck isn’t AI capability, it’s organizational context. Without an ontology and memory of how the organization operates, AI agents are flying blind. Key points: * Current AI wins are mostly task-based (code generation, summarization); the bigger opportunity is system-level intelligence * For AI to do meaningful organizational work, it needs to understand who makes decisions, how they’re funded, and what’s been tried before * The missing piece: institutional knowledge and context that currently lives in people’s heads or is scattered across dozens of tools * Steve’s hope: leaders freed from status meetings and compliance toil can spend more time on strategy, experimentation, and building things that matter--- Hard Boiled Software is hosted by Dave Laribee [https://www.linkedin.com/in/laribee/]. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com [https://newsletter.nerdnoir.com?utm_medium=podcast&utm_campaign=CTA_1]

"Building Teams That Actually Learn" with Diana Larsen

Diana Larsen is a pioneering figure in the Agile movement who has been shaping how teams learn and work together since the late 1990s. Co-author of the foundational Agile Retrospectives (with Esther Derby) and Liftoff (with Ainsley Nies), Diana brings decades of experience helping organizations build learning cultures. Her recent work with Lead Without Blame (co-authored with Tricia Broderick) extends her focus on leadership that supports team autonomy and psychological safety. Episode Description What does it mean to build a learning organization? Why does that matter now more than ever? In this conversation, Diana Larsen traces her journey from the earliest days of what would become the Agile movement to her current work with leaders navigating today’s complex, constantly shifting landscape. Diana shares hard-won insights on why retrospectives so often fail to deliver value (and what actually makes them work), how team chartering accelerates performance, and why the human side of software development keeps getting short-changed in favor of shiny new tools. Along the way, she introduces FAST (Fluid Adaptive Scaling Technology)—an emerging approach that synthesizes open space principles, self-selection, and dynamic reteaming into something genuinely different from the heavyweight scaling frameworks that dominate the conversation. Struggling to make your retros meaningful? Wondering how to support teams without a dedicated Scrum Master? Or just curious what someone who’s been in this game for 25+ years sees on the horizon? This episode offers both practical wisdom and the long view that only comes from sticking around long enough to see the patterns. Links & Resources Guest Links * Diana Larsen’s Website [https://www.dianalarsen.com/] * Diana Larsen on LinkedIn [https://www.linkedin.com/in/dianalarsenagileswd/] * Team Liftoffs [https://teamliftoffs.com/] — Neil Taylor’s continuation of the liftoff/chartering work Books by Diana Larsen * Agile Retrospectives: A Practical Guide for Catalyzing Team Learning and Improvement [https://pragprog.com/titles/dlret2/agile-retrospectives-second-edition/] (2nd Edition) [https://pragprog.com/titles/dlret2/agile-retrospectives-second-edition/] by Esther Derby, Diana Larsen & David Horowitz * Liftoff: Start and Sustain Successful Agile Teams [https://pragprog.com/titles/liftoff/liftoff-second-edition/] (2nd Edition) [https://pragprog.com/titles/liftoff/liftoff-second-edition/] by Diana Larsen & Ainsley Nies * Lead Without Blame: Building Resilient Learning Teams [https://leadwithoutblame.com/] by Diana Larsen & Tricia Broderick Books & Articles Mentioned * The Year Without Pants: WordPress.com and the Future of Work [https://scottberkun.com/yearwithoutpants/] by Scott Berkun — on distributed work at Automattic/WordPress * Agile Software Development with Distributed Teams [https://www.jeckstein.com/distributed-teams/] by Jutta Eckstein (2010) — early work on remote/diffuse teams * The Human Side of Enterprise [https://www.amazon.com/Human-Side-Enterprise-Annotated/dp/0071462228] by Douglas McGregor — the Theory X/Theory Y framework Tools, Frameworks & Concepts * Self-Determination Theory [https://en.wikipedia.org/wiki/Self-determination_theory] — an academic framework on autonomy-supportive leadership * Open Space Technology [https://openspaceworld.org/] — the meeting format that inspired elements of FAST * Dynamic Reteaming [https://www.amazon.com/Dynamic-Reteaming-Wisdom-Changing-Teams/dp/1492061298] — the practice of teams reforming based on work needs * FAST Agile [https://www.fastagile.io/] — Fluid Adaptive Scaling Technology, developed by Quinton (Ron) Quartel Shout Outs * Esther Derby [https://estherderby.com/] — co-author of Agile Retrospectives * Norm Kerth [https://www.dorsethouse.com/authors/kerth.html] — retrospectives pioneer, connected to the retrospective facilitator gatherings * David Horowitz [https://www.linkedin.com/in/dshorowitz/] — co-author on the 2nd edition of Agile Retrospectives, CEO of Retrium [https://www.retrium.com/] * Ainsley Nies [https://www.linkedin.com/in/ainsleynies/] — co-author of Liftoff * Tricia Broderick [https://igniteii.com/] — co-author of Lead Without Blame, founder of Ignite Insight + Innovation * Neil Taylor [https://www.linkedin.com/in/nealdtaylor/] — carrying forward the Team Liftoffs work (teamliftoffs.com [https://teamliftoffs.com/]) * Quinton (Ron) Quartel [https://www.linkedin.com/in/quintonquartel/] https://www.linkedin.com/in/quintonquartel/— creator of the FAST framework [https://www.fastagile.io/] * Scott Berkun [https://scottberkun.com/] — author of The Year Without Pants * Jutta Eckstein [https://www.jeckstein.com/] — author of an early distributed teams book * Douglas McGregor [https://en.wikipedia.org/wiki/Douglas_McGregor] — management theorist (Theory X/Theory Y) * Matt Plavcan [https://www.linkedin.com/in/matthew-plavcan/] — Introduced Dave to Diana, making this podcast possible * Agile Open Northwest [https://www.agileopennorthwest.org/] — open space conference (Portland/Seattle) Topics Discussed The Evolution of Agile (and Why It Keeps “Dying”) Diana offers a compelling lens on the recurring declarations that “Agile is dead”—connecting them to the diffusion of innovation curve. Each time Agile crosses from one adopter group to the next (pioneers to early adopters to majority), the previous group declares it dead because it’s necessarily changing to accommodate new contexts. Key points: * Diana entered through XP in 1997, bringing experience with cross-functional, self-organizing teams from high-tech manufacturing * Every wave of “Agile is dead” corresponds to a diffusion curve transition * The community’s strength has been its ability to learn its way through major shifts—from co-location to remote, from desktop to mobile, and now to AI Why Retrospectives Fail (And What Actually Works) The retrospective framework from Agile Retrospectives isn’t just a meeting format—it mirrors how the human brain naturally processes decisions. When teams skip steps or reduce retros to “what went well/what didn’t” lists, they lose the collaborative thinking that drives real improvement. Key points: * The framework follows natural human cognition: attention → perception → implications → decision * “When your retrospectives go well, every other meeting in your organization goes well” * Retros that don’t affect the next iteration’s plan aren’t working—they’re building process resentment * The goal isn’t catharsis; it’s collaborative decision-making that creates buy-in along the way Team Chartering and Liftoffs Taking time at the beginning to establish shared purpose, working agreements, and context dramatically accelerates team performance. Diana’s work with Neil Taylor is bringing this practice into the remote-first era. Key points: * Three essential elements: purpose/vision, who’s doing the work and how, and contextual environment * The charter is “always a draft”—available for adjustment but providing a reference point * For remote teams, co-located liftoffs create lasting human connection that sustains virtual collaboration * Team chartering and retrospectives work together as a system—retro insights can update the charter The Disappearing Agile Roles Problem As organizations shed Scrum Masters and Agile coaches, they often expect managers to absorb these responsibilities without developing the skills or capacity to do so well. Key points: * Many organizations hired managers for paperwork and HR compliance, not team nurturing * Lead Without Blame addresses what leaders can do to create conditions for performance without becoming full-time coaches * The human problems in organizations won’t be solved by new tools—they require developing new capabilities in people * Leaders’ plates are overflowing; burnout is the predictable result FAST: A Different Approach to Scaling Fluid Adaptive Scaling Technology combines open space, self-selection, dynamic reteaming, and XP-style small slices of work into an alternative to heavyweight scaling frameworks. Key points: * Created by Quinton (Ron) Quartel after observing open space conferences and asking, “What if we applied this to software development?” * Teams form around work on a short cadence (2-3 days to a week), demonstrate progress, then reform based on what’s needed next * Eliminates the “60% on this project, 30% on that” cognitive overhead while maintaining flexibility * Allows quick response to changing product direction without waiting for quarterly planning cycles The Autonomy-Supportive Leader Diana traces a through-line from Douglas McGregor’s 1952 Theory X / Theory Y work through self-determination theory to today’s challenges. Really good leadership has looked similar for decades—we just keep defaulting back to control. Key points: * Theory Y assumes people want to do good work and will if barriers are removed; Theory X assumes they need to be pressured * Self-determination theory provides academic grounding for autonomy-supportive leadership * Diana’s current work: meeting with leadership groups to share new ideas and help reframe challenges * Focus on environments, team dynamics, and leadership as the three elements that optimize organizational capability Thanks for listening! If this conversation resonated with you, subscribe to Hard Boiled Software wherever you get your podcasts. Follow us for more conversations with systems thinkers who care about the craft of building software. Visit the Nerd/Noir newsletter [https://newsletter.nerdnoir.com/podcast] for episode archives, show notes, and more explorations at the intersection of technology and the human condition. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com [https://newsletter.nerdnoir.com?utm_medium=podcast&utm_campaign=CTA_1]

"The Skills That Survive AI" with Michael Feathers

Michael Feathers is the author of Working Effectively with Legacy Code, the de facto survival guide for developers dealing with gnarly, untested systems for nearly two decades. He’s been a thought leader in software craftsmanship, refactoring, and technical excellence throughout his career. * Working Effectively with Legacy Code [https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052] — Michael’s seminal book on wrangling tougher codebases * R7K Research & Conveyance [https://www.r7krecon.com/] — Michael’s company specializes in software and organizational design * Michael’s LinkedIn Profile [https://www.linkedin.com/in/michaelfeathers/] — Follow for Michael’s current events and thinking Episode Summary Dave and Michael have an honest conversation about what’s happening to the software profession right now. From the dopamine hit of programming to the commoditization of hard-won skills, they explore professional identity, second-order effects of AI adoption, and what remains evergreen in a rapidly shifting landscape. Topics Covered Where has all the dopamine gone? * Programming’s intrinsic reward loop—the rush of solving problems and getting closure through code * Whether AI usage can replicate that satisfaction * The difference between the TDD flow state and the AI-assisted workflow Availability Bias & Path Dependency * Michael’s biggest AI concern: accepting the first generated solution without considering alternatives * Software’s deep path dependency—early decisions compound * The Starbucks analogy: do you care about coffee or caffeine? Design or delivery? Navigating Programmer Ego Death * The psychological transition as coding skills get commoditized * Reframe: loving programming means loving understanding and building systems—social, organizational, economic * Evolution from “problem solvers” to “problem articulators” Second-Order Effects of AI in Organizations * Junior dev displacement may be overstated * Dan Shipper’s model: pairing senior/junior developers with separate agents plus shared AI ops support * The real risk: generating code you don’t understand at unprecedented speed * Metrics creep—lines of code (or token usage) returning; Goodhart’s Law incoming What Skills Remain Evergreen * Examples over specifications—few-shot prompting works; Brian Marick’s “an example would be handy right about now” * Sidestepping problems—knowing when to abandon a dead-end approach * Value judgments in architecture—AI can’t implicitly understand context-specific values * Learning how to learn—meta-learning strategies matter more than any specific technology The Architecture Moat * No “GitHub for architecture”—no standardized documentation unit * Design and architecture remain more human-protected domains * Experiment: asking an LLM “how would Michael Nygaard design this system?” This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit newsletter.nerdnoir.com [https://newsletter.nerdnoir.com?utm_medium=podcast&utm_campaign=CTA_1]