Podcast
The Mob Mentality Show
Hosted by The Mob Mentality Show · EN
Chris Lucian and Austin Chadwick discuss all things agile and product development from a mob programming perspective.
11episodes
Episodes
Newest firstAll episodes
Collaborative Software Design in Practice: Kenny (Baas) Schwegler on DDD, EventStorming, and Real Team Learning
Jan 2700:48:56Tap to summarizeJoin the Mob Mentality Show for a stimulating conversation with Kenny (Baas) Schwegler, co-author of Collaborative Software Design, as we explore the intersection of software architecture, team collaboration, and organizational culture. In this episode, we uncover how collaborative software design and Domain-Driven Design (DDD) transform software delivery from a siloed, top-down process into a shared problem-solving experience that integrates business, engineering, and user perspectives to get all the data on the table. Kenny shares practical strategies for running collaborative modeling sessions, including EventStorming, example mapping, and guerrilla modeling. Learn how to engage stakeholders and developers in the same room, foster shared understanding, and evolve systems iteratively while navigating complex organizational dynamics. Whether you’re designing greenfield systems or improving brownfield applications, these techniques empower teams to reduce miscommunication, avoid groupthink, and make better design decisions faster. We also dive into the cultural and systemic challenges that impact software delivery, including implicit hierarchies, patriarchal structures, and unspoken decision-making rules. Discover how amplifying quiet voices, balancing power dynamics, and creating psychologically safe environments directly improve software outcomes. Kenny explains how effective collaboration goes beyond tools and patterns—it’s about shaping a culture where diverse expertise is actively leveraged and trade-offs are surfaced transparently. Key takeaways from this episode include: - How collaborative software design bridges business understanding and technical feasibility. - Practical methods to introduce DDD, even in non-collaborative environments. - Techniques to iteratively discover, model, and implement solutions in complex domains. - Strategies to neutralize hierarchy and amplify underrepresented perspectives in decision-making. - Insights on integrating team autonomy, Team Topologies principles, and flow-based development for continuous improvement. This episode is essential for software architects, product leaders, developers, and anyone invested in high-performing, collaborative teams. Gain actionable insights on designing software as a collective endeavor, aligning stakeholders, and creating systems that support innovation, adaptability, and inclusion. Video and Show Notes: https://youtu.be/Mqbm2kwpsHo
Transcribe →Applying TDD and XP in Graphical, Binary, and Legacy Codebases with Sam Taggart
Jan 1300:40:24Tap to summarizeWhat happens when Agile, Extreme Programming, and Test-Driven Development meet a world dominated by hardware, graphical programming, and binary artifacts? In this episode of the Mob Mentality Show, we’re joined by Sam Taggart to explore what it really takes to introduce modern software engineering practices into environments like LabVIEW, embedded systems, and industrial software teams. These are contexts where deployment can be slow, feedback loops can be expensive, and “just refactor it” feels like it is not an option. We dig into why applying XP, TDD, mob programming, and continuous integration looks very different when your software is tightly coupled to physical devices, firmware, and test equipment. Sam shares practical insights on adapting Agile ideas so they actually work in hardware-constrained environments, rather than forcing patterns designed for web apps onto teams that live in a very different reality. A major theme of the conversation is change. How do you sell new engineering practices to skeptical teams? How do you introduce better ways of working without triggering resistance or fear? And how do you help organizations move forward when legacy code, specialized tools, and long-established habits get in the way? We also spend time on a deceptively simple but critical idea: knowing what “good” looks like. From testing strategies and code quality to team collaboration and delivery confidence, having a clear vision of good engineering makes it far easier to experiment with better practices and avoid cargo-cult Agile. This episode is especially relevant if you work with LabVIEW, embedded systems, firmware, industrial or hardware-adjacent software, or if you’re leading teams where Agile adoption feels harder than the books make it sound. Topics include: - Applying TDD and XP in graphical, binary, and legacy codebases - Mob programming and collaboration in hardware-heavy environments - Continuous integration and delivery when deployment is constrained - Introducing Agile ideas without alienating experienced engineers - Reducing risk while improving feedback and quality - Helping teams see and aim for better engineering outcomes Video and Show Notes: https://youtu.be/Kxzn_2aYMIM
Transcribe →Fully Engaged Mob vs Disengaged Mob: How Team Engagement Directly Impacts Software Delivery
Jan 600:18:40Tap to summarizeWhat actually separates a fully engaged mob from one that feels flat, quiet, or stuck? And why does that difference matter far beyond team morale? In this episode of the Mob Mentality Show, we explore how team engagement directly impacts software delivery, learning, and long-term sustainability. Drawing from real mob programming experiences—ranging from high-energy, large-group collaboration to small teams struggling with disengagement—we unpack the patterns behind why engagement rises or fades. Rather than offering a one-size-fits-all playbook, this conversation treats engagement as a systems and complexity problem. We discuss how engagement shows up differently in quiet vs. loud mobs, how personal context and learning overload can influence participation, and why disengagement is often a signal—not a character flaw. You’ll hear practical ways facilitators and teams can probe, sense, and respond when engagement drops, including: - The difference between intrinsic and extrinsic motivation in mob settings - When small format changes help—and when they’re only a temporary band-aid - How psychological safety affects learning, contribution, and retention - Techniques for surfacing hidden confusion without negatively calling people out - Why repeated work and lack of progress quietly drain motivation - When disengagement points to deeper systemic or environmental issues We also connect engagement to outcomes leaders care about: flow, learning speed, delivery quality, and business impact. This isn’t about forcing fun or “rah-rah” energy—it’s about creating conditions where people want to contribute, can contribute, and see the value of innovating together. Whether you’re a developer, facilitator, tech lead, or engineering manager, this episode offers concrete signals to watch for and experiments to try—while respecting the complexity of human systems. If you’ve ever wondered why one mob feels alive and another feels exhausting, this conversation can help you see what’s really going on beneath the surface. Video and Show Notes: https://youtu.be/P0-PWstQhqk
Transcribe →Escape Room Style Mobbing
Dec 900:23:37Tap to summarizeEscape Room Style Mobbing is a real collaboration pattern many teams run into, even if they do not have a name for it yet. In this episode of the Mob Mentality Show, we break down the spectrum between two very different mobbing modes: fast, noisy, interruption-heavy “escape room” mobbing and the quieter, deliberate, research-first approach some teams rely on instead. Across the conversation, they share concrete examples from dozens of mobs they have been part of over the years. You will hear what actually happens in high-energy mobs that optimize for speed, flow, and rapid experiments. You will also hear what shifts when a team leans into slow, deep thinking, deep learning, cautious change, and single-threaded communication. The episode digs into the real tradeoffs: - When interruptions accelerate discovery and when they create friction or waste - Why some teams thrive in a “pull everyone in now” environment while others feel overwhelmed or blocked by the noise - Why the same people might switch styles depending on context, psychological safety, or the kind of problem they are solving You will also hear how teams manage learning in each mode, how business expectations can map with the mob’s behavior, how different personalities respond to high-octane collaboration, and why both styles can be healthy when used intentionally in the right context rather than by accident. If you work on Agile teams, practice Mob Programming, care about delivery flow, or you simply want to understand why your team’s collaboration energy swings from chaotic to quiet, this episode gives you language and mental models you can use right away. FYI: Video and Show Notes: https://youtu.be/kZ9yH5Fibn4
Transcribe →Abid Quereshi on No Such Thing as the Agile Manifesto
Dec 300:47:59Tap to summarizeIn this Mob Mentality Show episode, we sit down with Abid Qureshi for a candid and eye-opening look at what Agile Software Development was meant to be versus what the industry turned it into. If you’ve ever wondered why “Agile” feels bloated today, why teams still struggle to adapt quickly, or why universities are still teaching outdated models like Waterfall, this conversation will hit home. Abid shares his perspective on why the original movement focused on lightweight methods, experimentation, and uncovering better ways of developing software. He explains how the software industry drifted toward heavyweight processes and off-the-shelf frameworks, and what gets lost when organizations treat Agile as a set of fixed best practices (independent of a code context) instead of an ever evolving software craft. He also challenges long-held assumptions about technical excellence, design, and the true sources of agility in modern software development. We dig into: - The contrast between early agile software development and what “Agile” represents today. - Why the title “Agile Manifesto” is misleading and what the document was actually about. - How advances in technology, object-oriented programming, automated testing, and continuous integration made genuine agility possible. - Why real adaptability comes from reducing the cost of change, not adding more process. - The danger of scaling up bureaucracy instead of scaling down and improving engineering practices. - How non-technical contributors sometimes unlock unconventional, high-value ideas that technical experts overlook. - Why many higher education programs still teach waterfall-style thinking and how that hurts new developers entering the industry. - The missed opportunity for universities to lead innovation in software development instead of echoing outdated industry norms. If you care about XP, Lean thinking, software craftsmanship, technical excellence, or getting back to the heart of agility, this episode offers a practical and refreshing reset. Abid’s stories and insights challenge the assumptions that hold teams back and point toward a more grounded, engineering-driven approach to modern software development. Video and Show Notes: https://youtu.be/nJI-veSJdkQ
Transcribe →Rewriting the Rules of Mob Programming: One Tiny Step at a Time with Kevin Vicencio and Alex Bird
Nov 1800:43:47Tap to summarizeWhat happens when you combine daily mini-retrospectives, Test-Driven Development in absurdly small steps, and Chess Clock Mobbing? You get a radically different iteration on collaboration, continuous improvement, and extreme programming—and that’s exactly what we explore in this episode of the Mob Mentality Show with guests Kevin Vicencio and Alex Bird. Kevin and Alex are on a team who didn’t just mob the canonical way—they experimented with variations and discovered something that seems faster, tighter, and even more collaborative in many ways. From refining how teams use retrospectives to guide daily improvements, to pioneering a new high-intensity form of teaming called “Chess Clock Mobbing,” their approach is relentless in its pursuit of learning and team flow. In this conversation, we dig into: - How daily retros and real-time feedback can evolve your team culture fast - Why working in smaller TDD steps can paradoxically lead to faster results - The mechanics and mindset behind Chess Clock Mobbing - “Evil TDD Ping Pong” as a way to level up test design and shared understanding - Building a culture of trust, safety, and continuous experimentation - Techniques for maintaining momentum, engagement, and learning in remote-first dev teams - The power of absurdly small experiments and the compounding effect of micro-improvements Whether you’re an Agile coach, XP practitioner, software engineer, or just curious about pushing the boundaries of collaborative development, this episode delivers deep insights, real practices, and actionable takeaways you can try with your team tomorrow. 📌 Don’t forget to like, comment, and share if this episode sparked an idea or a conversation! Video and Show Notes: https://youtu.be/w3vvpJ3VKew
Transcribe →From Rogue Robots to Reliable Releases: My Journey into Extreme XP
Nov 1100:13:49Tap to summarizeIn this lightning-talk-style Mob Mentality Show episode, Austin Chadwick takes you through his real-world evolution from clunky, waterfall-style processes to fully cranked-up Extreme Programming (XP)—a journey defined by failures, breakthroughs, and a relentless pursuit of clean, test-driven code. Starting in a rigid, process-heavy dev shop where a typo fix required presidential-level approvals, Austin shares how years of stagnation, big batch releases, and public demo disasters (including rogue robots) led him to ask the big question: What if we actually did Extreme Programming all the way—no compromises? This episode digs into: - Why doing half of XP might be worse than doing none - The hidden cost of tolerating just “one bug” - What daily delivery and value-first thinking really look like in practice - Experiments on how to survive (and thrive) when your dev culture thinks you’re “too extreme” - The real tradeoffs of turning XP, TDD, and refactoring up to volume level 11 - When agile and XP becomes a “cargo cult” - Lessons from being one of the lone voice for clean code in an organization stuck in the middle Alongside co-host Chris Lucian, Austin reflects on the resistance many developers face when advocating for full adoption of XP practices—like pair and mob programming, evolutionary design, continuous delivery (CD), test driven development (TDD), and bug-free codebases. They also explore how to escape local optima by introducing meaningful “mutations” to your dev environment and culture. Whether you're a software engineer tired of firefighting and regressions, a team lead wondering why your “agile” isn’t working, or a practitioner curious about what it means to really commit to Extreme Programming, this conversation pulls no punches. 👍 Like the episode? Hit the thumbs up, drop a comment, and share with someone who’s still debating whether TDD is “worth it.” Video and Show Notes: https://youtu.be/AKXRGmSYgWs
Transcribe →Mob Anti-Patterns Explained: Fly on the Wall, Runaway Driver, and More with James Herr
Nov 400:42:17Tap to summarizeIn this episode of the Mob Mentality Show, we sit down with James Herr from Flexion to explore the dark side of mob programming — the anti-patterns that quietly erode collaboration, learning, and flow in your team. From the “Fly on the Wall” who silently observes but never joins in, to the “Runaway Driver” who takes control and goes rogue, and the “Knee-High Navigator” who dictates every keystroke, these relatable scenarios shine a light on what can go wrong during mob or ensemble programming sessions — and, we share some potential experiments ideas to address them. James shares real-world insights from years of ensemble experience, walking through the subtle behaviors and team dynamics that lead to these anti-patterns. The discussion moves beyond surface-level symptoms to uncover psychological safety, learning theft, and communication habits that make or break mobbing success. You’ll learn: - What causes common mob programming anti-patterns — and how to recognize them early - Practical techniques to help newcomers integrate smoothly without being overwhelmed - How to use “strong-style” collaboration and mini-retros to restore balance in a team - When to “let it cook” vs. when to intervene to prevent runaway drivers - How to cultivate high-level navigation and reduce micromanagement in coding sessions - Why “white-glove” onboarding for visitors and new mobbers accelerates learning and trust - How naming patterns improves team reflection, vocabulary, and psychological safety This episode dives deep into the human side of technical collaboration, blending agile principles, systems thinking, and lived experience from teams practicing mob and ensemble programming every day. Whether you’re a developer, product owner, engineering leader, or agile coach, you’ll walk away with practical strategies to identify and correct these patterns — before they derail your team’s effectiveness. Video and Show Notes: https://youtu.be/NxLor73Rgds
Transcribe →Doing Less, Achieving More: Lean, Clean, and Simple Lessons from Agile Principle #10
Oct 2800:22:06Tap to summarizeCan simplicity be your team’s most powerful productivity tool? In this episode of The Mob Mentality Show, we explore Agile Manifesto Principle #10: “Simplicity—the art of maximizing the amount of work not done—is essential.” This isn’t abstract Agile theory — it’s real-world stories and lessons from software teams who’ve learned how to cut waste, focus on what matters, and deliver more by doing less. We share hands-on examples from their work in Mob Programming, Extreme Programming (XP), and Lean Thinking, unpacking how simplicity shows up in everyday team decisions. 🎯 In this episode, you’ll learn: - When saying “no” isn’t the answer — and how to say “yes, and…” instead with... - How small automations can save time, build trust, and remove repetitive work - The power of reducing batch size to get faster feedback and higher quality - What the “nice-to-have bag” taught us about ruthless prioritization - How profitability can actually hide inefficiency and technical waste - Why focusing on the 20% of work that drives 80% of value keeps teams sharp - How to stay lean, adaptable, and resilient — even when things feel “comfortable” - What "gold-plating" really means in the context of software development This conversation hits the intersection of Agile mindset, team collaboration, and developer culture. It’s packed with takeaways for engineers, team leads, and product owners who want to create sustainable, high-performing teams without falling into overproduction or other lean wastes. 💬 Whether you’re scaling a software product, improving team flow, or rethinking your backlog, this episode helps you bring clarity and simplicity to your workflow — so your team can do less, achieve more, and deliver what truly matters. Video and Show Notes: https://youtu.be/W9t4GOU4Vmk
Transcribe →Effective BDD: Seb Rose and Gaspar Nagy on Real Collaboration, Example Mapping, and Automation Patterns
Oct 2100:48:57Tap to summarizeIn this episode of The Mob Mentality Show, we sit down with Gáspár Nagy and Seb Rose, two highly respected voices in the Behavior-Driven Development (BDD) community, to discuss their brand-new book, Effective Behavior-Driven Development, published by Manning Publications. Seb and Gáspár share their hard-won insights from over 15 years of helping teams adopt BDD the right way—focusing not just on tools or syntax, but on real collaboration, shared understanding, and sustainable automation practices. You’ll learn how Example Mapping helps teams uncover hidden assumptions, why Automation Patterns matter for long-term maintainability, and how the Effective BDD book brings together their previous works on Discovery, Formulation, and Automation into one cohesive guide for practitioners. The conversation covers: - What “effective” BDD really looks like in modern agile teams - Why collaboration—not tooling—is the true heart of BDD - How Example Mapping accelerates shared understanding and reduces rework - What automation patterns many test suite needs (and what pitfalls to avoid) - How to write maintainable, meaningful, and human-readable scenarios - Insights from their journey creating Effective BDD and its roots in the patterns community - Real-world lessons from decades of coaching, training, and hands-on development Whether you’re a developer, tester, product owner, or agile coach, this episode will help you see BDD not as a buzzword, but as an actual way to turn up the good on collaboration and quality for software delivery. Video and Show Notes: https://youtu.be/0Yf8oPPKlv8
Transcribe →