Hard Boiled Software

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 DescriptionWhat 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 & ResourcesGuest Links* Woody Zuill’s Website* Woody Zuill on LinkedIn* Software Teaming: A Mob Programming, Whole-Team Approach by Woody Zuill & Kevin MeadowsBooks & Articles Mentioned* Teaming: How Organizations Learn, Innovate, and Compete in the Knowledge Economy by Amy Edmondson — the book that made Woody wish he’d called it “teaming” from the start* Extreme Programming Perspectives — edited collection containing the original “Mob Programming” article by ThoughtWorks practitioners* Pair Programming Illuminated — early book on pair programming that influenced Llewellyn Falco’s thinking* Team Flow: The Psychology of Optimal Collaboration by Jef van den Hout & Orin C. Davis — research on achieving shared psychological flow in teams* “Big Ball of Mud” by Brian Foote & Joseph Yoder — the classic 1997 paper on the most common software architecture patternTools, Frameworks & Concepts* Software Teaming / Mob Programming — a whole-team approach to software development at one computer* Strong-Style Pairing — 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 — Fluid Adaptive Scaling Technology, developed by Ron Quartel, is closely related to software teaming* #NoEstimates — 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 — research concept from Jef van den Hout on achieving collective psychological flow in teamsPeople Referenced* Llewellyn Falco — inventor of Strong-Style Navigation, creator of ApprovalTests, recommended by Woody for an interview* Amy Edmondson — Harvard professor, author of Teaming* Linda Rising — speaker and author who advised Woody early on to tell stories in presentations* Ken Schwaber — 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 — Dutch researcher at Eindhoven University of Technology, developed the Team Flow model* Mihaly Csikszentmihalyi — psychologist who originated the concept of psychological flow* James Herr — Woody’s collaborator on talks about mob programming and AI* Fred Zuill — Woody’s brother, who described AI as “a rather faulty, somewhat moderately skilled collaboration partner.”* Andrea Zuill — Woody’s wife, children’s book author and illustrator (Wolf Camp, Sweety, Dog vs. Strawberry, and others)* Kevin Meadows — co-author of Software Teaming* Brian Foote & Joseph Yoder — authors of the “Big Ball of Mud” paper* Taiichi Ohno — Toyota Production System pioneer (referenced by Dave)Topics DiscussedThe Art of Iterating on a TalkWoody 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 yearsFrom Pair Programming to Software TeamingThe 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 TeamworkWoody 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 experienceVariations in Practice Around the WorldHaving 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 demandsAI, Learning Debt, and the Enduring Value of Working TogetherThe 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*

Connecting the Dots from Strategy to ExecutionSteve Elliott is the founder and CEO of Dotwork, 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, a community-driven playbook for better organizational decision-making, and is the author of The Decisive Company.Episode OverviewWhy 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 — AI-native strategy and portfolio platform* Steve Elliott on LinkedIn* The Decisive Company: How High-Performance Organizations Connect Strategy to Execution by Steve ElliottTools, Frameworks & Concepts* The Uncertainty Project — 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 — framework for calibrating decision speed to reversibility* John Boyd’s OODA Loop — Observe, Orient, Decide, Act decision-making framework* Team Topologies — framework for organizing teams around cognitive load and flow (referenced by Dave)* Product Operating Model — outcome-oriented approach to organizing product development work* Event Sourcing — a software architecture pattern where system state derives from an audit trail of events (referenced by Dave)People Referenced* John Cutler — Head of Product at Dotwork, author of The Beautiful Mess newsletter* W. Edwards Deming — management theorist, referenced by Dave (”by what method”)* John Boyd — military strategist, creator of the OODA loopTopics DiscussedFrom Consulting to Serial EntrepreneurshipSteve’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 startupsThe Strategic Alignment ProblemThe 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 getsThe Limits of Existing ToolsSteve 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 downOntologies, Knowledge Graphs, and Organizational MemoryThe 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 SystemsA 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 capabilityDotwork’s Vision: Intelligence Without More DashboardsDotwork’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 mistakesAI Beyond Task-Level ProductivityThe 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. 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

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 DescriptionWhat 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 & ResourcesGuest Links* Diana Larsen’s Website* Diana Larsen on LinkedIn* Team Liftoffs — Neil Taylor’s continuation of the liftoff/chartering workBooks by Diana Larsen* Agile Retrospectives: A Practical Guide for Catalyzing Team Learning and Improvement (2nd Edition) by Esther Derby, Diana Larsen & David Horowitz* Liftoff: Start and Sustain Successful Agile Teams (2nd Edition) by Diana Larsen & Ainsley Nies* Lead Without Blame: Building Resilient Learning Teams by Diana Larsen & Tricia BroderickBooks & Articles Mentioned* The Year Without Pants: WordPress.com and the Future of Work by Scott Berkun — on distributed work at Automattic/WordPress* Agile Software Development with Distributed Teams by Jutta Eckstein (2010) — early work on remote/diffuse teams* The Human Side of Enterprise by Douglas McGregor — the Theory X/Theory Y frameworkTools, Frameworks & Concepts* Self-Determination Theory — an academic framework on autonomy-supportive leadership* Open Space Technology — the meeting format that inspired elements of FAST* Dynamic Reteaming — the practice of teams reforming based on work needs* FAST Agile — Fluid Adaptive Scaling Technology, developed by Quinton (Ron) QuartelShout Outs* Esther Derby — co-author of Agile Retrospectives* Norm Kerth — retrospectives pioneer, connected to the retrospective facilitator gatherings* David Horowitz — co-author on the 2nd edition of Agile Retrospectives, CEO of Retrium* Ainsley Nies — co-author of Liftoff* Tricia Broderick — co-author of Lead Without Blame, founder of Ignite Insight + Innovation* Neil Taylor — carrying forward the Team Liftoffs work (teamliftoffs.com)* Quinton (Ron) Quartel — creator of the FAST framework* Scott Berkun — author of The Year Without Pants* Jutta Eckstein — author of an early distributed teams book* Douglas McGregor — management theorist (Theory X/Theory Y)* Matt Plavcan — Introduced Dave to Diana, making this podcast possible * Agile Open Northwest — open space conference (Portland/Seattle)Topics DiscussedThe 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 AIWhy 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 wayTeam Chartering and LiftoffsTaking 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 charterThe Disappearing Agile Roles ProblemAs 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 resultFAST: A Different Approach to ScalingFluid 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 cyclesThe Autonomy-Supportive LeaderDiana 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 capabilityThanks 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 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

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 — Michael’s seminal book on wrangling tougher codebases* R7K Research & Conveyance — Michael’s company specializes in software and organizational design* Michael’s LinkedIn Profile — Follow for Michael’s current events and thinkingEpisode SummaryDave 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 CoveredWhere 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 workflowAvailability 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 incomingWhat 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 technologyThe 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