The Mob Mentality Show

Join 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

What 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

What 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

Escape 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

In 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

What 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

In 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

In 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

Can 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

In 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

In this episode of The Mob Mentality Show, hosts Chris Lucian and Austin Chadwick sit down with Joshua (Schwa) Aresty to explore how remote teams thrive through communication, collaboration, and creativity in modern software development. Together, they unpack three powerful and practical topics shaping the future of agile engineering: 🔹 Remote Work Communication Patterns What makes remote collaboration work — and what breaks it? The discussion dives into real patterns that distributed teams can adopt to communicate more clearly, stay aligned, and maintain momentum without burnout. Learn how to balance synchronous and asynchronous teamwork for maximum flow and productivity. 🔹 Mobbing vs Pairing What’s the difference between mob programming and pair programming in practice? The conversation breaks down the strengths and trade-offs of each approach. Discover when a mob or a pair works best, how to transition between the two, and how these methods can build a culture of shared learning, faster feedback, and higher-quality code. 🔹 Voice Coding and Accessibility Joshua brings unique insights into coding by voice — an approach that challenges traditional ideas of how developers write code. Hear how voice coding improves ergonomics, accessibility, and inclusivity in software engineering. This segment highlights how diverse workflows and adaptive tools can unlock new levels of creativity and collaboration. Whether you’re an agile practitioner, developer, team lead, or engineering manager, this episode delivers practical takeaways you can apply immediately: - Strengthen communication in remote or hybrid teams - Choose between pairing and mobbing effectively - Foster inclusive, accessible engineering environments - Improve team learning and knowledge sharing through ensemble programming 🎧 Tune in to learn how collaborative coding techniques, like mobbing and pairing, can transform not just how software is written — but how teams connect, learn, and grow. Stay connected and join the conversation with the Mob Mentality community — where we explore the people, practices, and patterns that make software development more human, sustainable, and effective. Video and Show Notes: https://youtu.be/vBGwXhTFUkI

🧹 In this episode of the Mob Mentality Show, we quickly cover the “Code Janitor” anti-pattern — a hidden trap that can quietly undermine team performance. While teams are often formed to maximize collaboration, learning, and flow, certain team dynamics can introduce dysfunctions. The “Code Janitor” role is one of them. What exactly is the "Code Janitor" anti-pattern? It happens when one person slips into the role of silently cleaning up after the team — fixing formatting, organizing files, refactoring, tidying the codebase, or generally taking on tasks that would be better shared by the whole team. On the surface, it may look helpful, but in reality, it can limit transparency, reduce shared ownership, and end up being "too little, too late." This episode explores why this happens, how to recognize it, and most importantly, what options teams have for mitigation. Listeners will hear hot takes on: - How small, well-intentioned behaviors can spiral into anti-patterns - Why the janitor role reduces the learning opportunities for the whole team - Strategies to keep mob cleaning collaborative and balanced - Tips for fostering healthy communication and shared responsibility - How leaders and team members can encourage practices that improve flow instead of hiding work - Is the “Code Janitor” anti-pattern the lesser of two evils and therefore permissible in some situations? 😅🧼🧽 Whether you’re new to mob programming or a seasoned practitioner, this quick episode is a reminder that even small patterns can have big impacts on engineering culture and team productivity. If you’re passionate about agile software development, software craftsmanship, and continuous improvement, this episode will give you a new lens on how teams work together and how to spot warning signs before they hurt you. Video and Show Notes: https://youtu.be/rckIiSodfyY

In this episode of the Mob Mentality Show, we dive into the growing tension between the fast rise of Agentic AI systems and the foundational principles of Extreme Programming (XP) and Lean Software Development. As more teams experiment with multi-agent LLM orchestrators like Claude, GPT-4, and others, does the risk of generating untested, low-quality "AI slop" increase—unless guided by tight feedback loops, small batch sizes, and real tests? We ask: - Can Agentic AI truly support Agile and XP practices—or is it working against them - Are we moving toward AI-driven productivity or just automating chaos faster? - What practices can keep teams grounded as tools grow more autonomous? Join hosts Austin Chadwick and Chris Lucian as they explore: - The difference between AI-assisted XP excellence and Agentic AI slop - Real-world dev experiences using multi-agent architectures - How to apply small iterations, pairing/mobbing, and test-first thinking in AI-augmented workflows - The pitfalls of Agentic orchestration without lean guardrails - Why mob programming and XP might be the missing link in managing AI complexity - Tips for maintaining engineering rigor in a world of AI copilots and task runners If you're experimenting with AI in software teams—or trying to balance automation with craftsmanship—this conversation is packed with insights, practical takeaways, and a few strong opinions. 📢 Share this episode with anyone navigating the messy intersection of AI tools and solid software practices. Video and Show Notes: https://youtu.be/efW8eaOGL28

In this episode of the Mob Mentality Show, Chris Lucian is joined by Amy Dredge, Will Munn, and Mike Clement to dive deep into how Open Space Technology (OST) is transforming the way engineering leaders learn, connect, and solve real-world challenges together. Whether you're a Staff+ engineer, an engineering manager, or a tech leader looking for meaningful growth, this episode uncovers how OST creates space for peer-to-peer learning that’s spontaneous, high-impact, and deeply human. We explore: The Engineering Leadership Summit — what it is, why it matters, and how it's unlike traditional conferences. How Open Space Technology empowers attendees to shape their own agenda and focus on the most pressing leadership challenges. The shift from passive presentations to active conversations among experienced engineering leaders. Lessons learned from hosting and attending open space events — from hallway chats to high-trust collaboration. How tools like GatherTown help replicate the spontaneity of in-person connection in a remote world. Why this format resonates deeply with Staff+ and senior engineering leaders seeking authenticity, relevance, and practical insight. We also compare remote vs. in-person open space events, dig into accessibility, and share actionable tips for running your own internal or external open space sessions inside engineering orgs. 🎧 This is a must-listen for anyone serious about growing engineering culture, building leadership communities, and fostering real, unscripted learning. 💬 What’s your experience with open space formats in tech? Drop a comment or DM us on social. 📌 Topics Covered: Open Space Technology in Engineering Staff+ and Engineering Manager Peer Learning Engineering Leadership Summit Preview GatherTown for Remote Events Community Building in Tech Agile Leadership in Practice Unconference vs. Traditional Conferences FYI: Video and Show Notes: https://youtu.be/domldsgqkDs

In this episode of the Mob Mentality Show, we sit down with Henrik Ståhl, a product manager and advocate for collaborative software development, to explore how mob programming, MVPs, and agile leadership can reshape the way teams build products. Henrik shares a unique product manager perspective on mob programming—why it’s more than just a coding practice and how it becomes a powerful tool for communication, knowledge sharing, and true collaboration across teams. We dive into what happens when product managers actively join mob sessions, the unexpected benefits for decision-making, and how it reduces waste and rework. We also tackle one of the most misunderstood concepts in product development: the MVP (Minimum Viable Product). Henrik explains why many teams fall into the trap of either shipping low-quality “minimums” or overengineering “full products,” and what viable should really mean. You’ll hear insights on how sustainability, scalability, and learning fit into the MVP conversation—whether you’re at a large enterprise or an early-stage startup. Finally, we unpack the infamous phrase “Move Fast and Break Things.” Henrik reframes the idea, showing how moving fast doesn’t mean sacrificing quality or creating chaos, but instead building the right contingency plans, embracing adaptability, and ensuring that speed leads to sustainable outcomes rather than long-term failures. If you’ve ever wrestled with questions like: How can product managers contribute directly in mob programming? What does “viable” really mean in MVP? How do you balance moving fast with building lasting, maintainable products? How can teams avoid rework, miscommunication, and wasted effort? …this episode is packed with practical takeaways and perspectives you can use right away. 🎙️ Listen in to learn how to build better products together—with less blame, fewer silos, and more shared ownership. 📌 Topics Covered: Mob programming from a product manager’s perspective The real meaning of MVP and why “Minimum Viable Whatever” fails Rethinking “Move Fast and Break Things” for sustainable speed Communication, collaboration, and continuous improvement in agile teams Knowledge sharing, reducing waste, and eliminating silos Video and Show Notes: https://youtu.be/JCZcJ6xT7-8

In this episode of the Mob Mentality Show, we explore Agile Manifesto Principle #11: “The best architectures, requirements, and designs emerge from self-organizing teams.” This principle often sparks debate. Can teams really create great architecture and design without top-down control? Can autonomy be granted when the team isn’t ready for it? Does self-organization only work when the right skills, trust, and shared values are already in place? Can control without competence cause chaos? We dig into what it really means for modern teams and why it’s still controversial today. Topics covered in this episode include: Why is Agile Manifesto Principle #11 frequently misunderstood in organizations? What dangers arise when control is handed over without building XP competence first? How can mob programming and collective learning raise a team’s ability to self-organize effectively? What role do psychological safety, trust, and leadership support play in enabling autonomy? Why must Agile principles be applied together rather than in isolation? How does Principle #11 connect to Lean thinking and the reduction of common wastes in software development? What real-world lessons show how solid architectures can emerge naturally through collaboration? What practical advice can leaders and agile coaches use to balance empowerment with readiness? The conversation highlights both the promise and the potential pitfalls of applying Agile Principle #11. This episode is useful for anyone who works in software development, engineering leadership, product management, or Agile coaching and wants to understand how to create conditions where self-organizing teams thrive instead of flounder. Video and Show Notes: https://youtu.be/lTPtr8t3yaM

This special episode of The Mob Mentality Show is a cross-post from Tuple’s podcast/videocast Distributed, where Chris and Austin join host Jack Hannah for an in-depth conversation about mob programming, agile leadership, and the evolving role of AI in software development. Originally recorded for Distributed, this discussion brings a fresh outside perspective to topics Chris and Austin have explored in over 300 episodes of The Mob Mentality Show—but here, they dive even deeper into the origins of mob programming, how it spread across the organization, and what it takes to protect team culture while scaling. Listeners will hear stories about early experiments—like rearranging office spaces to make pairing/mobbing possible—navigating challenging product owner relationships, and using “cellular division” to grow teams without losing their collaborative spirit. The conversation also covers AI in social coding, from generating code in domain-specific languages to treating AI as another member of the mob, plus honest thoughts on whether AI could ever replace pair or mob programming. Key Topics in This Cross-Post Episode: How one team’s mob programming experiment became an org-wide practice Lessons from creating and sustaining 300+ agile/XP episodes Office and workflow changes that enable collaboration at scale Maintaining team culture through growth and change Where AI fits (and doesn’t) in mob and pair programming Practical advice for teams without internal XP mentors The future of AI in collaborative software development If you’re interested in agile leadership, developer experience, extreme programming, or the human side of software engineering, you’ll get proven strategies you can apply immediately—plus inspiration from seeing how practices spread beyond their starting point. Video and Show Notes: https://youtu.be/Cd0L4jyaUIg

What does it really look like when Agentic AI systems are integrated into some modern software teams? In this episode of the Mob Mentality Show, we sit down with David Hirschfeld—founder and CEO—to unpack real-world experiences with Agentic AI, prompt engineering, and workflow automation in dev environments. This is not a theoretical discussion. David brings firsthand stories of building and deploying AI-powered agents. We explore the hands-on challenges and breakthroughs that come with treating AI like a junior developer, giving it structured workflows, and designing systems that can improve with feedback. Highlights include: Is “prompt engineering” dead? What Agentic AI is doing right now to reduce busywork and boost flow and what are the current shortcomings How AI agents can integrate with tools like Jira and Slack The cultural shifts needed to make AI part of your agile team Pitfalls of over-reliance on AI and the importance of confidence thresholds (e.g., big bang AI slop vs. small batch AI with verified output) How voice and vision AI are expanding what’s possible in software development When to automate, when to augment, and when to stay manual The surprising power of “smart laziness” in engineering productivity Lessons from real teams automating their development processes Whether you’re a dev, product manager, or just AI-curious, this episode offers a rare behind-the-scenes look at how agentic systems are being used today—not in the future—to transform engineering work. Video and Show Notes: https://youtu.be/cMhnIeGu3Js

How do you scale an agile team without sacrificing collaboration, flow, or developer experience? In this episode of the Mob Mentality Show, we’re joined by Brice Ruth—engineering leader at Flexion and ensemble programming advocate—for a deep dive into what it takes to build high-functioning, adaptable software teams through a concept he calls “mob meiosis.” We explore Brice’s journey from solo coding to full-time mob programming, and how his experience in the industry and in government contracts shaped his philosophy on team dynamics, learning cultures, and system design. If you’re looking for actionable insights into building fast feedback loops, enhancing developer onboarding, or evolving your mob into multiple autonomous mobs, this is the episode you don’t want to miss. 🔍 What you’ll learn: What “mob meiosis” is and how it enables team scaling without silos How to engineer feedback loops that operate across code, communication, and team structure Why ensemble programming improves developer flow, learning, and job satisfaction Lessons from transitioning into mobbing full-time—and how to make it sustainable Tips for fostering a culture where pairing, mobbing, and continuous improvement thrive Whether you’re an agile coach, engineering manager, or developer looking to elevate your team’s practices, Brice brings a sharp, experience-backed perspective on what it means to lead with feedback, prioritize team health, and scale with purpose. 🎙️ Subscribe to the Mob Mentality Show for more episodes on ensemble programming, agile culture, and modern software team dynamics. Video and Show Notes: https://youtu.be/W0eJFMzbBME

In this eye-opening episode of the Mob Mentality Show, we sit down with software engineer and consultant William Bernting to explore a radical approach to hiring, teamwork, and technical leadership. William walks us through his real-world experience with mob programming interviews—a collaborative hiring process where candidates join the team in an ensemble coding session, not a contrived solo coder test. He shares the surprising benefits of evaluating candidates through communication, alignment, and problem-solving over individual technical trivia. We dive into: Why mob programming is a great way to assess team fit and long-term success How to structure collaborative interviews that reduce anxiety and reveal true strengths What happens when you ditch traditional project-led methods and focus on predictability through steady flow How the Cynefin framework helps make sense of complex team dynamics and guides leadership decisions What freelance engineering looks like when trust, autonomy, and collaboration lead the way William also discusses how he's made his work more stable and sustainable—for both clients and team members—without relying on estimates or rigid plans. Instead, he uses continuous delivery, test-driven development (TDD), and mobbing to achieve results that are both reliable and adaptable. Whether you're a hiring manager rethinking your interview process, an engineer looking to join better teams, or a leader trying to move beyond chaotic delivery cycles, this conversation offers practical takeaways and fresh perspective. 🧠 Topics covered: - Mob Programming Interviews - Collaborative Hiring - Cynefin Framework in Tech - Predictability Without Projects - Freelancing in Software Engineering - Team Fit Over Resume Skills - Agile Leadership Without Estimates Video and Show Notes: https://youtu.be/nnR3_V8FrMQ

In this episode of the Mob Mentality Show, we sit down with Taimoor Imtiaz—CTO at a fast-moving, bootstrapped startup—for a raw, insightful dive into how his small dev team applied mob programming, trunk-based development, and GitHub Flow to accelerate delivery without sacrificing code quality. Taimoor shares the journey of how his team transitioned from traditional PR-based workflows to real-time collaboration in mobs. Along the way, they faced timer-switching friction, monorepo challenges, and the trade-offs of scaling extreme programming practices in a production environment. If you’ve ever wondered how mob programming plays out in a high-pressure startup setting—or whether trunk-based development is viable outside of big enterprise environments—this conversation is for you. What you’ll learn in this episode: How GitHub Flow can be adapted for trunk-based development Why mob programming improved debugging and reduced defects Where mob timebox timers went wrong—and what the team did about it The real impact of developer experience and culture on delivery speed Lessons learned from using a monorepo in a fast-growing codebase Using extreme programming when resources are tight Whether you’re a startup CTO, team lead, or individual contributor looking to evolve your team’s workflow, this episode offers real-world insights into modern software development practices that actually work under pressure. Video and Show Notes: https://youtu.be/yTbzycv9qw4

📚 How does Mob Programming really work in the college classroom? In this episode of the Mob Mentality Show, we reconnect with Professor Ben Kovitz to explore the raw lessons, surprising wins, and tough challenges from a full semester of mob programming in a college software design course. Ben shares what happened when he replaced traditional lectures with real-world collaboration. The results? Students developed practical coding skills, improved their communication, and learned to work together as a true software team—less ego, more shared ownership. From early wins with small group design exercises to complex struggles with C++ memory management and GUI libraries, Ben walks us through what worked, what bombed, and what he’d change next time. We break down: Why mob programming created stronger learning and better teamwork than expected How structured rotations got everyone participating and avoiding common pairing pitfalls The highs and lows of using C++ and Qt in a classroom setting The unexpected power of students struggling through real software challenges together Lessons on undo implementation, design patterns, and memory management from hands-on mobbing How a semester wasn’t enough time to fully teach long-term code stewardship and habitable design What might scale—or fall apart—if mob programming were applied to larger classes How this classroom experience mirrors the real world: legacy code, fast feedback, technical debt, and learning as you go Whether you’re a software engineer, an educator, or someone passionate about team learning, this episode gives you actionable insights into mob programming as both a teaching tool and a real-world development practice. We also explore questions like: Can mob programming work with 30+ students? How can solo work and group collaboration coexist in the best learning environments? What does it take to create code that’s not just correct—but actually pleasant to maintain? If you’re interested in agile learning, collaborative coding, and pushing the boundaries of how we teach and work as software teams, this episode is for you. Video and Show Notes: https://youtu.be/kbNEfAcfmeo

🎲 In this episode of the Mob Mentality Show, we dive into a unique and game-changing (literally) approach to learning Test-Driven Development (TDD) with Ted M. Young (JitterTed), John Wilson, and Janis Kampe. Discover the origin story of the TDD board game that started as a simple teaching aid and evolved into a powerful learning experience for developers, teams, and even product managers. Hear how this game went from casual pub nights to becoming a staple for some in team training sessions, meetups, and Agile coaching toolkits. We break down: ✅ How the TDD board game helps teams internalize the deeper steps of TDD beyond the basic "Red-Green-Refactor" mantra. ✅ Why the game’s focus on prediction, risk management, and working in small steps transforms the way people think about writing code. ✅ The surprising ways the game builds psychological safety, making it accessible even to people new to TDD or nervous about exposing gaps in their knowledge. ✅ How the game naturally leads to ensemble (mob) programming and seamless transitions into hands-on coding platforms like CyberDojo. ✅ Practical tips on using the game to onboard, coach, and improve team collaboration—whether you're remote, hybrid, or in-person. We also explore the importance of failing safely, incremental learning, and how the game allows players to experience both the thrill of success and the consequences of cutting corners—without the high stakes of real-world code. Whether you're a developer, Agile coach, product manager, or just curious about TDD, this episode will give you actionable insights on: 🛠 How to enable continuous learning in your teams. 🎯 Why predicting outcomes matters more than just getting green tests. 🎮 How gamification makes TDD fun, social, and sticky. Key Topics: TDD Board Game Mechanics & Variations Psychological Safety in Learning Risk vs. Reward in Software Development Ensemble Programming (Mob Programming) Transitioning from Game to CyberDojo Practical Coaching Tools for TDD and XP Building Stronger Developer-Product Manager Collaboration Video and Show Notes: https://youtu.be/GjcUdoS5K6I

👨‍💻 Legacy code isn’t just old untested code—it’s a symptom of deeper problems in your organization. In this no-fluff episode of the Mob Mentality Show, we’re joined by Agile and technical coach Wouter Lagerweij to break down why legacy issues persist and how shared responsibility between product and engineering is the key to meaningful change. 🎯 What we cover in this episode: - Why legacy systems are just as much about organizational baggage as they are about outdated code - How true Agile teaming—swarming, pairing, mobbing—can unlock speed, learning, and fun - Why your bug tracker is a graveyard, and how a zero bug policy can reset your team’s quality bar This is a grounded, experience-rich conversation packed with practical insights for developers, team leads, product managers, and anyone serious about improving delivery without adding more process theater. ✅ You’ll come away with: * A broader definition of legacy and how to confront it * Concrete examples of effective team collaboration models * A new perspective on software quality and defect tracking * Proven ways to foster stronger cross-functional ownership 👤 **About the guest:** Wouter Lagerweij is an independent Agile Coach based in The Netherlands and operating throughout Europe. He loves spending time with teams and organizations to figure out how to improve the way they make software, and make it more fun. To make that happen he uses the knowledge and skills gathered in over eighteen years of experience applying Agile processes and practices from XP, Scrum, Kanban, Continuous Delivery, DevOps, Lean and Systems Thinking. To turn those improvements into real business opportunities, he has added Lean Startup/Lean Enterprise approaches. Occasionally, he even uses common sense. 😅 Video and Show Notes: https://youtu.be/me9CSgmIRk8

🎙️ What happens when software engineers and leaders don’t speak the same language? How do context-free Agile practices and technical dogma lead teams astray? And how do we create engineering cultures that deliver real business value without burning out? In this Mob Mentality Show episode, we sit down with Kyle Rowland—leadership and software consultant, 20-year software engineering veteran, and author of Powerful Profitable Software Products: The Executive Guidebook—to tackle the tough questions at the heart of sustainable, impactful software delivery. 💡 What We Cover in This Episode: 🔧 The Engineering-Leadership Impedance Mismatch Why do engineering leaders and business leaders often talk past each other? Kyle shares how focusing on both “how” we build and “what” we build—can prevent burnout, bottlenecks, and bad outcomes. We explore why real innovation depends on creating win-win systems, not siloed thinking. ⚠️ The Danger of Context-Free Agile Many teams argue about Agile, TDD, TBD, and pairing without understanding the systems that make those practices work. Kyle unpacks how context, principles, and shared goals determine whether these tools help or hurt—and how to avoid cargo cult Agile. 🔬 Empiricism vs. Philosophy in Tech Decisions Is the Agile Manifesto's call for empiricism enough? Or is there still a place for a priori reasoning (argument from principle) in engineering? Kyle argues for a balanced approach—using experiments where we can, and wisdom where we must. ⏱️ The 1:40 Rule and Escaping Tactical Overload Are you buried in endless 1-on-1s and tactical firefighting? Kyle introduces the “1:40 rule”—a lens for spotting when leaders are too involved in details and not investing in system-level growth. He explains how to avoid organizational entropy and shift your focus from maintenance to momentum. 📚 Plus: Behind the Book We go deep on Kyle’s new book Powerful Profitable Software Products, exploring practical ways leaders can move from reactive chaos to purpose-driven product delivery—while empowering teams and aligning with business goals. 🎧 Whether you're an engineering leader, product owner, or software dev, this episode is packed with insights on leadership, systems thinking, quality, speed, and how to build software that matters. FYI: Video and Show Notes: https://youtu.be/oCK1lMa2s9A

What if your beliefs—about work, people, or even yourself—are quietly holding you back? In this episode of The Mob Mentality Show, we sit down with visual thinker, author, and accidental Mob Programming anthropologist Dave Gray to unpack the power of belief, clarity, and collaboration in tech and beyond. Dave Gray is known for Liminal Thinking—a book about understanding the invisible beliefs that shape behavior and systems. But did he know he was writing a book about us? Turns out, our Mob Programming origin story and Dave’s journey are more connected than you’d expect. With roots as an artist, Dave brings a rare perspective to complex tech and business systems. From prior infographic posters that demystified RFID and Bluetooth when they first came out, to visual guides on inner transformation and his latest books, Dave's work simplifies the complicated and builds bridges for real understanding. With Dave we explore: What led Dave from agile software development to Liminal Thinking Why most Agile transformations fail How to navigate confusing resistance—are people really lost, or just saying “no”? The principles behind creating safe spaces and disrupting unhelpful routines Visual and liminal thinking for fostering organic authentic change, not just communication tricks Raw observation vs. narrative: how perception can distort reality Why having lunch with someone you think is "crazy" or "stupid" might be the wisest move The psychology behind tech resistance, organizational inertia, and true agility We also revisit how Woody Zuill and our original Mob Programming team with Chris Lucian smashed the belief that “real work” only happens in cubicles and outside of "meetings." The mob origin story had Liminal Thinking on full display as that team reflected, questioned, and ultimately acted in defiance of broken norms. The result? A shift in how we define space, collaboration, and innovation as Dave captures in his book. If you work in tech, lead change, facilitate teams, or just feel stuck inside outdated ways of working, this episode is for you. Video and Show Notes: https://youtu.be/fWF6kQBRdhg

In this thought-provoking episode, we sit down with Tobias Mayer—author, coach, and longtime voice in the Agile world—to explore the journey from his early discovery of XP (Extreme Programming) in 1997 all the way to today’s debate around the death of Scrum. Tobias shares his personal transformation from developer to Scrum Master, his resistance to early XP, and how he learned great practices from developers he managed. We unpack his reflections on Agile’s semantic drift, the role of Scrum Masters as change agents vs. bean counters, and what happens when teams do Agile without even knowing the Agile Manifesto. 🔍 Topics we dive deep into: Discovering XP through a paper against it 😅 When “Scrum” became a buzzword and what was lost in translation What it really means to live the values of the Agile Manifesto XP coaches, grassroots change, and learning from your team The difference between top-down control and emergent discovery Misused metaphors in tech: “firefighting,” “war rooms,” “soldiers,” and more Are software teams more like engineers, artisans, or ensembles? Can DORA metrics (DevOps Research and Assessment) prove or disprove Agile’s effectiveness? We also dig into mob programming (aka mobbing)—what it means, why the name matters, and whether or not new metaphors like “ensemble programming” or “teaming” (à la Amy Edmondson) better reflect how high-performing teams really work. 💡 Plus: The problem with the Product Owner (PO) role in Scrum Why language in IT shapes behavior—for better or worse Applying Artful Making to modern product development Rethinking business through the lens of theatre, philosophy, and cooperative economics The importance of psychological safety, dissent, and experimentation in creating real agility Tobias brings rich context from classics, theology, and history—yes, even turning a conference t-shirt into fashion—to challenge how we think about building products, teams, and businesses. 🛠️ Whether you're into XP, Scrum, Mob Programming, Lean, or simply want to rethink your metaphors and language at work, this episode delivers grounded insight, sharp critique, and fresh perspectives. 👉 Subscribe for more conversations at the intersection of agile thinking, real teamwork, and modern product development. Video and show notes: https://youtu.be/ZFoY-De91BE

🎙️ In this episode of The Mob Mentality Show, we’re joined by Professor Ben Kovitz—a former software developer with 15 years of industry experience who went on to earn a PhD and is now teaching Computer Science at Cal Poly Humboldt. Prof Ben flips the script and brings his own real-world mob programming questions—challenges he’s faced while mobbing live with college students in the classroom. This is not theory. These are hard-won questions from the trenches of mob programming in a learning environment, where curiosity meets complexity, and group dynamics get real. 🔍 We dive deep into 5 key challenges: 1. Deep Thought vs. Mob Timers: How do you carve out time to think deeply, explain thoroughly, or research ideas in a setting where timers tick every 3 minutes? Is it “wrong” to step away from the mob to figure something out? We discuss balancing solo exploration with group momentum, and how to build a culture that supports both. 2. Upfront Design or Just Start Mobbing? Do you need to pre-design work before mobbing, or can product discovery and agile planning happen in the mob itself? We explore Kanban, Continuous Delivery (CD), and even SPIDR story splitting as tools for flowing work in real time. 3. The Overrun Navigator: What happens when a mob gets too rowdy and drowns out the navigator—especially one who doesn’t yet know what to do? We unpack the difference between “good rowdy” energy and “bad rowdy” imbalance, and how facilitation, structured roles, or even a moment of silence can reset the team. 4. The Strong Opinion Navigator: Is it okay for someone with strong, often-correct opinions to mob effectively? How do we avoid stifling experimentation or learning? We tackle the value of letting experiments speak, coaching with humility, and using dominant voices to model vulnerability instead of control. 5. Mobbing with Documentation and AI: Should the mob read documentation together? What about using AI tools? We cover how teams can mob to teach effective doc reading, search strategies, and prompt engineering, while still adapting workflows to individual learning zones and WIP (Work in Progress) constraints. 💡 This episode is full of insights on: Group facilitation in real-time coding Balancing solo and group learning Creating psychological safety in a mob Adapting mob rules to context—not dogma Bringing agile, XP (Extreme Programming), and education together in the mobbing practice Video and Show Notes: https://youtu.be/nAAI5f7-vTs

🏈 Welcome to another episode of the Mob Mentality Show, where we explore the intersection of software development, leadership, and real-world lessons—from the unexpected to the game-changing. This time, we're talking Coaching Credits—as seen in the addictive mobile football game Retro Bowl—and how they map directly to trust, influence, and leadership in software teams. 🎙️ What are Coaching Credits? In Retro Bowl, Coaching Credits represent the respect and trust you’ve earned from players, staff, and fans. They let you upgrade your team, hire top-tier talent, and level up your environment. In software development, we argue Coaching Credits are just as real—earned through Extreme Programming (XP), Mob Programming, Test-Driven Development (TDD), Continuous Delivery (CD), and strong relationship-building. 👶 Austin kicks it off with a story about trying to stay awake helping his wife with their new baby—turning to Retro Bowl as a late-night lifeline. That sparks a deep dive into what the game teaches us about: Building trust and respect through small wins The balance between performance and relationships Using “credits” (influence) wisely inside and outside your team How to upgrade your environment and talent pool over time What happens when you try to “spend” influence you don’t actually have 👨‍💻 In Dev Culture Terms: Earn trust by delivering value. Spend it by coaching others, refactoring code, upgrading environments, or influencing org-wide decisions. Just like in Retro Bowl, you can overreach. Think: trying a big move when your trust bank is empty = a bounced check. 📘 We also tie Coaching Credits to Stephen Covey’s 7 Habits—specifically, the idea of an emotional bank account—and reflect on how these lessons align with the origin story of mob programming. 🚨 Key Questions We Explore: Can you go into Coaching Credit “debt”? Is quick wins and trust the only way forward when you're starting from zero? Are you too transactional in how you lead or code? Should someone build a Software Dev Sim game like Retro Bowl? 😅 💡 If you're a software engineer, tech lead, or engineering manager, this episode offers a fun but surprisingly deep framework for thinking about how trust, respect, and influence shape the way you build products and teams. Video and Show Notes: https://youtu.be/ZWgOkphBFNI

🎙️ Ever faced a product vision so massive it felt impossible to start? In this Mob Mentality Show episode, we tackle the art and science of Story Splitting — breaking down huge dreams into small, deliverable slices without losing momentum or clarity. We explore real-world strategies, including: Asking the hard questions like Do we really need to release everything at once? Using SPIDR (Spike, Path, Interface, Data, Rules) to guide story splitting Implementing Feature Flags (tools to enable/disable features without deploying new code) for flexible delivery Creating color-coded diagrams to visualize release order and dependencies Practicing "Yes, and" techniques to manage big customer asks without abandoning Agile values Running post-mortem retrospectives focused on improving splitting practices Mapping ideas with Discovery Trees (visual structures for feature evolution) Handling the tension between Big Bang marketing launches and incremental delivery Influencing sales and marketing teams to only sell what's already done vs. selling the future Identifying the impact of poor story splitting on technical debt and customer trust Differentiating splitting technical work vs. splitting user-facing features Teaching business stakeholders the fundamentals of CD (Continuous Delivery) and good story practices implicitly vs. explicitly Working through known unknowns vs. unknown unknowns in product discovery Using the Cynefin Framework (a model for navigating complexity) to decide splitting approaches Prioritizing with cost of delay and story split diagrams to maximize value This episode is packed with hands-on advice for developers, product managers, Agile coaches, and leaders looking to move fast without breaking things. Whether you're struggling with overwhelming customer requests, complicated roadmaps, or internal misalignment, learning how to split the impossible is key to success in Agile, Continuous Delivery, and Lean Product Development. Video and Show Notes: https://youtu.be/MjwIkiM25xM

🎙️ What’s really happening inside your engineering org? In this episode of the Mob Mentality Show, we sit down with Philip Borlin, Director of Engineering and advocate for lean thinking, mobbing, and team capability building, to uncover how Gemba Walks, smaller batch sizes, and healthy team nudges reveal the actual state of your tech organization—not just what reports say. We explore how leaders can stop flying blind and start leading based on facts from the field. 🔍 Topics Covered: ✅ Gemba Walks (Japanese term meaning “go to the real place”): Why your assumptions about how work gets done are probably wrong How spending even one hour a week in the mob or at the code level changes everything The myth of managing solely through middle managers Why high-fidelity information beats filtered reporting Remote-friendly adaptations: mobbing, Lean coffees, and async insight gathering ✅ Mobbing (also known as ensemble programming): How mobbing surfaces capability gaps and builds shared understanding Growing capabilities without enforcing rigid standards Real stories of capability fire drills, single points of failure, and org fragility “Low and slow” growth as the only sustainable path to true skill development? ✅ Fixing Batch Size and WIP (Work In Progress): How large batches lead to delivery waste, delays, and bugs The surprising power of reducing ticket size to unlock flow Socratic coaching at stand-ups to improve team work slicing Giving permission to drop non-priority work and focus only on what matters ✅ Building a Learning Culture: Why capability resilience > retaining every team member forever Using “nudges” and peer pressure the right way Investing in bright spots without ignoring skeptics Cultivating environments where psychological safety and growth feed off each other 💡 Whether you’re a Director of Engineering, Tech Lead, Agile Coach, or Software Engineer, this episode gives you practical ways to lead with clarity, scale team capability, and build resilience into your org’s DNA. 🎧 Subscribe now so you don’t miss the drop: 👉 https://www.mobmentalityshow.com/ Video and Show Notes: https://youtu.be/bFMD0AsVDUA

What if your team didn’t need branches at all? 💥 In this episode of The Mob Mentality Show, we sit down with Ron Cohen, CTO and co-founder of Bucket, to unpack the real story behind Trunk Based Development (TBD) and the practical use of Feature Flags. Ron stirred the pot online by challenging common assumptions around TBD — and now he’s here to clear the air. We talk about: What Trunk Based Development really means (Hint: It’s not just “no branches”) Why TBD isn’t just a Git strategy, but a safety mindset often backed by solid practices like Pair Programming, Mob Programming, and TDD (Test-Driven Development) Gitflow vs. TBD — which one sets your team up to move faster and safer? The myth that TBD = chaos, and why short-lived branches might still play a role How mobbing and pairing can make TBD not just possible, but powerful We also dive deep into Feature Flags (a.k.a. Feature Toggles): Why Ron became obsessed with them — and how they changed how his teams ship code How to use toggles for faster releases, safer experiments, and smoother collaboration between devs, Product Owners (POs), and marketing The difference between feature flags that require a deployment and those that don’t The value of “dogfooding” your features in production before a full rollout Why not all toggles are created equal — from simple UI switches to ops-level controls How to avoid the mess of long-lived toggles and clean up after experiments (Austin, we're looking at you 😅) Plus: How flags can power A/B testing and internal beta programs Fowler’s definition of Feature Flags — and how it is in action Using toggles to build internal and external trust Ron’s framework for different kinds of flags in different contexts Whether you're deep into CI/CD (Continuous Integration/Continuous Delivery), trying to tame your branching strategy, or just want to ship smarter — this episode’s packed with insights you can use immediately. 🎧 Subscribe and listen on your favorite platform: 👉 https://www.mobmentalityshow.com/ Video and Show Notes: https://youtu.be/4PZN1yO8l2c

What happens when a college software design course ditches traditional lectures and embraces Mob Programming? In this episode of the Mob Mentality Show, we sit down with Ben Kovitz, a former software developer turned professor at Cal Poly Humboldt, to explore his innovative approach to teaching software design through mobbing. Topics Covered: ✅ From Industry to Academia: Why Ben left software development to become a professor and how he discovered mob programming. ✅ Redefining Software Education: Instead of 30 traditional lectures on software design, Ben’s students learn by doing—designing software while coding. ✅ The Power of Mobbing in the Classroom: How students collaborate in the mob of 8, rapidly sharing knowledge and tackling challenges together. ✅ Fast Learning vs. Lectures: Why mobbing enables faster knowledge transfer compared to passive lectures. ✅ Strong-Style Navigation: How rotations and fast timers helped to stimulate a highly effective learning environment. ✅ The Role of the Navigator: How students help each other navigate, learn C++ and the QT framework, and document key lessons from each mob session. ✅ Real-World Software Challenges: Simulating legacy code maintenance, evolutionary design, and design patterns like MVC (Model-View-Controller). ✅ Overcoming Student Struggles: What happens when students don’t know how to navigate? How asking for help and learning together fosters growth. ✅ Teaching Through Experience: Letting students experiment with flawed solutions before introducing better design principles. ✅ Assessment & Engagement: How Ben measures student participation, engagement, and learning outcomes in a mobbing environment. Why This Matters: Traditional software design education can leave students unprepared for the realities of refactoring real code and collaborative development. By integrating Mob Programming, refactoring techniques, and hands-on problem-solving, Ben Kovitz is equipping the next generation of developers with practical, real-world skills and deeper design insights. 📢 Subscribe to the Mob Mentality Show to stay updated on the latest insights in Mob Programming, Extreme Programming (XP), Agile, and collaborative software development! 🎧 Listen on your favorite podcast platform: https://www.mobmentalityshow.com 🔔 Don’t forget to LIKE, COMMENT, and SUBSCRIBE for more episodes on software development, coding education, and team collaboration! Video and Show Notes: https://youtu.be/Rajvp2nrg1A

🔥 How do you actually build great software developers? How do you debug like a pro? And what happens when XP (Extreme Programming) makes a comeback after the Scrum backlash? Join us as Garrick West—a seasoned XP practitioner, Agile coach, and software craftsmanship advocate—dives into: ✅ Building Agile Software Developers: From XP mentorship to industry-academia collaboration ✅ The Best Debugging Strategies: Unpacking The Debugging Book and applying its rules in a mob ✅ Reviving XP & Software Crafting: Why XP is more crucial than ever in Agile teams 🚀 Garrick's Story: From Early Coding to XP Champion Garrick started coding at 10 years old (at day camps in the 80s! 😅), earned a Computer Science degree, and had his development worldview shaped by reading the first edition of Extreme Programming Explained. He has worked at XP-centric organizations, trained teams in TDD (Test-Driven Development), Ensemble Programming, and CI/CD (Continuous Integration/Continuous Deployment), and even revamped a college curriculum from Waterfall to XP/Scrum. 🎯 "Building" Agile Software Developers The power of an XP coach early in a developer’s journey Public speaking as a dev skill? (Toastmasters, teaching at community college) What happened when Garrick helped convert a college curriculum from Waterfall to XP/Scrum? Industry experts + academia: How can professional devs and educators collaborate better? The apprentice model: What it means and why learning stages (like the Dreyfus Model) matter AI & developer education: Does AI replace early learning stages, or is it just a slick salesman? Scaling Gilded Rose Kata to different skill levels Test Coverage as a red herring—what should we focus on instead? 🐞 Debugging: The Missing Developer Superpower Ever heard of The Debugging Book? Most developers haven’t—but it’s a game-changer. We explore: Debugging as problem-solving, not just "stepping through" in an IDE The 9 Debugging Rules: From reading the manual to never throwing away a good test tool How to gamify debugging in a mob & introduce a "debugging auditor" role The anti-pattern of multiple experiments at once—and how to avoid it Why debugging is like navigating a labyrinth with a million wrong paths 🔄 Reviving XP & Software Crafting After the Scrum Backlash XP fills Scrum’s missing middle: Building the right thing (Scrum) AND building it right (XP) How Scrum without XP leads to a “Ball of Mud” in just 18 months Why XP + Lean is the ultimate combination Breaking free from sprints & pressure cookers—just focus on continuous iterations Can XP stand without Scrum? Or does Scrum need XP? 💡 Don’t miss this high-energy, insight-packed conversation with Garrick West! 📢 Comment below: What’s YOUR experience with XP, Agile, or debugging challenges? Video and Show Notes: https://youtu.be/vxLDm-13Ny4

🚀 How do Game Jams accelerate learning? Can mobbing make game development more effective? In this episode of the Mob Mentality Show, we dive deep into Game Jams, Mobbing, and Game Dev Collaboration with James Herr—a full-stack developer, game dev enthusiast, and published game creator on Steam. 🎮 What You'll Learn in This Episode: 🔹 What Are Game Jams and why they’re a must-try for devs? 🔹 The tech stacks and tools commonly used in Game Jams 🔹 How themes shape a Game Jam’s creativity and constraints 🔹 How James is bringing mobbing into Game Jams 🔹 The difference between solo development, swarming, and full mobbing? 🔹 Pros & Cons of Mobbing Game Jams—Does it boost creativity or slow things down? 🔹 How Discord & Twitch fuel real-time game dev collaboration 🔹 Can Twitch chat act as a “navigator” in game development? Does the live audience guide decisions? 🔹 How Game Jams reveal code smells faster and teach refactoring & design patterns 🔹 Why public game dev can be a game-changer for learning speed 🔹 How Game Jams can simulate real-world software challenges and improve teamwork 🔹 Mob timer tools & Git handover techniques for smoother collaboration 🤝 Why This Episode Matters: Mobbing isn’t just for software teams—it’s transforming game development, learning, and onboarding. James shares his firsthand experience mobbing with kids, running Game Jams with cross-discipline teams, and teaching mobbing roles in game dev. Whether you’re a seasoned developer, indie game creator, or just curious about Game Jams, this episode is packed with actionable insights! 📢 Want to Join the Game Dev Community? James discusses how Discord and Twitch connect developers worldwide, making it easy to collaborate, get feedback, and learn from others. Checkout James' communities here: https://jamcraft.io/ 🎧 Subscribe & Listen Now! Don’t miss out! Subscribe to the Mob Mentality Show and get notified when this episode drops: 🔗 https://www.mobmentalityshow.com/ Video and Show Notes: https://youtu.be/AZEH_FmBBKs

🚀 Why is there so much confusion around Test-Driven Development (TDD) and Automated Testing? Why do many developers struggle with testing, and what are they getting wrong? In this episode of the Mob Mentality Show, we sit down with Jason Swett—author, speaker, and a go-to expert on Rails testing—to unpack the most common misconceptions, challenges, and best practices in modern software testing. 🔍 Topics We Cover: ✅ Why Jason Swett is passionate about Automated Testing and why he wants to help the development community ✅ Misconceptions about TDD (Test-Driven Development)—not liking TDD itself vs. not liking something called "TDD" ✅ The reality of software testing—why most developers aren't doing it well and how to improve ✅ Testing vs. verification vs. specification—what is a test really? What is code? ✅ Red, Green, Refactor vs. Specify, Encode, Fulfill—what do these different ways of thinking about TDD highlight? ✅ Why software changeability matters and how to reduce the cost of ownership ✅ What are you actually testing? The difference between testing the product (e.g., squirt gun) vs. testing the system that builds it ✅ The role of automation in development—is code like factory machinery? ✅ How testing connects to broader software and team dynamics—beyond just writing tests ✅ Common pitfalls in testing and how to ensure your tests actually add value ✅ Logical debates vs. ego-driven arguments—how to have productive discussions about TDD 💡 Key Takeaways: 🔹 TDD is often misunderstood—before rejecting it, understand what it really is 🔹 Many developers struggle with writing the right kind of tests—knowing what to test is critical 🔹 Automated tests don’t just verify code; they help manage change and reduce long-term costs 🔹 Good testing and TDD are about more than just code—they’re about communication, clarity, and better software development 📌 Who should watch/listen? If you’re a developer, tester, software engineer, or tech lead who wants to improve your testing skills, understand TDD better, and learn from a Rails testing expert, this episode is for you! 🎧 Subscribe & Listen: Don’t miss an episode! Subscribe to the Mob Mentality Show on your favorite platform: 👉 https://www.mobmentalityshow.com/ 🔥 Join the Conversation! Have thoughts on TDD and Automated Testing? Share them in the comments! Video and Show Notes: https://youtu.be/_kL_tXiNcl4

How often should Agile teams reflect and adjust? Is your team on a road with switchbacks but they are not turning the wheel? In this episode of The Mob Mentality Show, we take a deep dive into Agile Principle #12, which states: "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." From a Mob Programming perspective, we explore what "tuning and adjusting" really looks like in high-uncertainty, high-interdependence work. Is it like steering a car, constantly making small adjustments, or is it something that requires far less steering? How do different approaches—Waterfall, 2 Week Scrum, and Mob Programming—each handle batch size and feedback loops with continuous improvement? In This Episode, We Discuss: ✅ Agile Principle #12—How it drives continuous improvement in teams ✅ "Regular Intervals"—Comparing Waterfall, 2-week Scrum sprints, and healthy mobbing ✅ Batch Size & Effectiveness—How small adjustments impact team agility ✅ Single vs. Double Loop Learning—Which leads to deeper team growth? ✅ Diversity & Focus—Does learning together accelerate improvement more than learning separately? ✅ The Cynefin Model—Navigating uncertainty and complexity in Agile work ✅ Liminal Thinking—How belief structures and assumptions impact team reflection Many teams go through the motions of retrospectives, but are they truly adjusting their behavior effectively? Join us for this insightful discussion where we challenge assumptions, explore deeper learning, and uncover the best ways to reflect, adapt, and improve as a team. 🎧 Subscribe & Listen: Don't miss this episode! Subscribe on your favorite platform here: 🔗 https://www.mobmentalityshow.com/ 📩 Connect with Us Let us know your thoughts in the comments! How does your team reflect and adjust? Video and Show Notes: https://youtu.be/ikmWgj44g28

How do you balance small, iterative progress with the vast unknowns of research and development (R&D)? Can test-driven development (TDD) literally or "in spirit" still provide value when you're navigating uncharted territory? In this episode of the Mob Mentality Show, we dive deep into the intersection of R&D Mobbing and software development, exploring real-world scenarios, strategies, and challenges teams face when innovating under uncertainty. What You’ll Learn in This Episode: 🔬 Chris's Journey with Mob Randori & R&D: From "we don’t know what we’re doing" to "we know what we’re doing"—how mob programming helped transform uncertainty into effective delivery. 🛠️ R&D vs. CD? Can teams practice continuous delivery (CD) even when tackling complex, unknown problem spaces? If so, is there a change in what is "delivered"? 📌 Keeping Small Steps & Feedback Loops in R&D: TDD is known for its rapid feedback and endorphin kicks—but how do you retain those benefits when exploring an unfamiliar landscape? 🔄 Adjusting Your Mobbing for the Task at Hand: When should you modify your mob programming approach to fit the nature of research-driven work versus production-level development? 🧗‍♂️ Clean Code Spelunking & Navigating the Unknown: Techniques for digging deep into existing codebases while ensuring safety and maintaining forward momentum. 🚩 Feature Flags & Safety in R&D: How to experiment with new ideas and do Trunk Based Development (TBD) without introducing instability to production. 📊 Transparency, Visualization & Business Buy-in: Addressing stakeholder fear of an "infinite problem space." 🧠 The Inverse of ZOMBIES in R&D Mode: How do you maintain focus, momentum, and value delivery when dealing with high levels of uncertainty? ⚡ Real-Life R&D Success Stories & Lessons Learned: Practical examples of mob programming driving R&D innovation in high-unknown environments. If you’ve ever wondered how to keep experimentation structured, learning fast, and delivery continuous—even when dealing with complex unknowns—this episode is for you! 📌 Watch More Episodes & Subscribe on Your Favorite Platform: https://www.mobmentalityshow.com/ 🔔 Don’t miss future episodes—hit the subscribe button! Video and Show Notes: https://youtu.be/nipbhFopqMM

Is the ultimate Domain-Driven Design (DDD) dream having a domain expert fully embedded in a Mob? Or does it come with hidden trade-offs? In this thought-provoking episode of the Mob Mentality Show, we explore the benefits, challenges, and real-world experiences of having a domain expert (or product owner) participate full-time in a Mob—not just as a consultant but as an active driver and navigator. 🔹 What We Discuss in This Episode: ✅ Quick Access vs. Full-Time Participation – Is it better to have a domain expert available when needed or fully immersed in the Mob? ✅ Real-World Stories – Chris shares insights from four product owners with different availability levels and how that impacted effectiveness. Austin reveals what happened when a domain expert became a full-time Mobber. ✅ The Pros of a Full-Time Domain Expert in a Mob – Faster decisions, deeper collaboration, improved knowledge transfer, and more! ✅ Natural Synergy with DDD – How DDD experts seamlessly jump into code naming, improving model alignment. ✅ Testers & Domain Experts: A Similar Integration? – The parallels between merging testers into a Mob and embedding domain experts. ✅ Potential Downsides – Does being in the Mob full-time reduce a domain expert’s ability to stay ahead in their field? ✅ Autonomy & Learning Diversity – How does this setup impact team growth and decision-making? ✅ Is This the DDD Dream? – With fewer moving parts (like event storming), does a domain expert in the Mob make DDD even more effective? ✅ The Power of Different Perspectives – Why having a built-in devil’s advocate can enhance team decision-making. ✅ The Truth About Cryptic Code – Can a domain expert help clarify unclear code in real time? 🎧 Don’t Miss This Insightful Discussion! Hit Subscribe and turn on notifications so you don’t miss future episodes! Find us on your favorite platform here 👉 https://www.mobmentalityshow.com/ What do you think? Would you want a domain expert full-time in your Mob? Drop a comment below! ⬇️ Video and Show Notes: https://youtu.be/7__ghFw_Z3g

Can a combo of Large Language Models (LLMs) and Domain-Specific Languages (DSLs) streamline development by automating repetitive patterns across teams? In this Mob Mentality Show episode, we dive deep into the intersection of AI-driven automation, code generation, and lean software development. Join us as we explore: ✅ The "Generator for the Generator" Concept – How AI-powered tools and Mob Programming can create DSLs that automate code generation at scale. ✅ Handling Cross-Domain Development with DSLs – How DSL arguments can be leveraged to generate applications across multiple domains while maintaining usability. ✅ Serverless Infrastructure as Code (IaC) & Auto-Generated Apps – How to use DSLs to automate cloud deployment with Angular or Streamlit apps. ✅ The Challenge of UI/UX in Generated Code – When UI is too generic, does it hurt usability? Can a DSL strike the right balance between automation and user experience? ✅ Regeneration vs. Continuous Development – Should teams work exclusively in the DSL, or also refine the code it generates? How to handle sync issues when regenerating applications. ✅ Turning Docs into Code with a DSL Converter – Automating workflows by transforming team documentation into executable code. ✅ Mob Automationist Role Inception – Is the next evolution of Mob Programming automating the automation? ✅ ZOMBIE Test Generation & Nested Python Dictionaries – How automated testing fits into the DSL-driven workflow and whether a DSL can be as simple as a structured Python dictionary. 🎯 Whether you’re a software engineer, an agile practitioner, or just fascinated by AI-driven development, this episode is packed with real-world insights into DSLs, LLMs, and the future of lean automation. 🔔 Don't miss out! Subscribe to the Mob Mentality Show on your favorite platform: 👉 https://www.mobmentalityshow.com/ Video and Show Notes: https://youtu.be/0q3jaX6_bfw

Explore the exciting intersection of human collaboration and artificial intelligence (AI) in software development with this insightful episode of the Mob Mentality Show. Recorded for the 2024 UACon Winter: The Future of Product Development Summit on December 10, 2024, Aaron Griffith and Parker Barrett joins Austin to dive deep into how Mob Programming and AI are reshaping the way we build and test software. This episode is packed with practical insights, real-world examples, and actionable strategies for leveraging AI with a mob programming style. Whether you’re an AI enthusiast, a software developer, or just curious about the future of collaboration, this session has something for you. What You'll Learn in This Episode: 🔹 What is Mob Programming? 🔹 The Origin Story of Mobbing with AI – Discover how our human teams began mobbing with AI tools like ChatGPT and GitHub Copilot to enhance software development processes. 🔹 AI-Driven Test Development in a Mob – See how AI can streamline test-driven development (TDD) workflows, making testing faster and more effective. 🔹 Testing with AI to Find ZOMBIES Test Cases (Zero, One, Many, Boundaries, Interface, Exceptional, Simplicity) – Learn how AI tools help identify missing test scenarios and code improvements. 🔹 AI Limitations and Warnings – Understand the ethical, technical, and operational challenges when incorporating AI into your workflows. 🔹 AI Mobbing Demo Highlights: AI-generated Flutter app complete with unit tests. AI-driven identification of ZOMBIES. Automated Continuous Integration/Continuous Deployment (CI/CD) pipelines powered by AI. Why This Episode Matters: As AI tools continue to evolve, understanding how they integrate with collaborative programming methods like Mob Programming and Extreme Programming (XP) is critical for staying innovative in the fast-paced world of software development. In this session, we not only discuss the benefits of AI but also provide a realistic view of its limitations and how to navigate them. Perfect For: Developers and teams exploring AI-powered tools. Agile practitioners and extreme programming enthusiasts. Anyone curious about the future of software development collaboration. Let’s shape the future of collaboration and development together! Video and Show Notes: https://youtu.be/BsFPbYX4WXQ

In this thought-provoking episode of the Mob Mentality Show, we dive into the world of extreme ownership within a multi-mobbing environment. What happens when a mob/team wants to make a decision, like extracting a method, refactoring to a new pattern, or reorganizing code boundaries? Should that decision wait for approval from outside teams? Or does extreme ownership mean trusting the mob to act autonomously for maximum flow efficiency? Topics Discussed: Autonomy vs. Consensus: Should mobs prioritize quick decision-making or seek input from external teams? Multi-Mob Context: Exploring the dynamics of multiple mobs interacting and how to handle shared ownership of repositories and projects. Inverse Conway Maneuver: Can designing your organization’s team structures to match the architecture you want your systems to have prevent this problem? Lean Thinking and Efficiency: How waiting for approvals from external owners can create lean wastes. Boundary Flexibility: Should code and team boundaries be rigid or adaptable to changing circumstances? The Monolith vs. Microservices Debate: Is the real issue a technical architecture debate or is the root problem found elsewhere? Scenarios and Examples: A hypothetical comparison of shared ownership in MS Word vs. MS Excel. The impact of Joe Justice’s Law on decision-making and team interactions. The challenge of managing too many communication nodes in multi-team environments. Key Questions Discussed: Is it more valuable to reduce the number of teams interacting with a repo? Should boundaries of ownership evolve with time? How can we balance flow efficiency with healthy collaboration across teams? How does "Nothing in Tech Matters Except XP" impact this discussion? Subscribe and Stay Connected: Don’t miss this insightful episode as we unravel these questions and more! Discover how the principles of extreme ownership and mob programming can transform team dynamics and decision-making processes in software development. 📢 Subscribe to the Mob Mentality Show on your favorite platform: https://www.mobmentalityshow.com. 🔔 Like, comment, and share to join the discussion and stay updated on upcoming episodes! Video and Show Notes: https://youtu.be/rAT-EurLnrI

In this episode of the Mob Mentality Show, we dive into Sustainable Pace, a core principle of the Agile Manifesto ("Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely"). From software development to youth sports, we explore the massively destructive effects of an unsustainable pace and highlight the transformative benefits of a culture grounded in sustainable practices. 🔥 Key Topics Covered 1. The Massively Destructive Results of Unsustainable Pace How the relentless work rate leads to burnout, dropouts, injuries, and errors. Insights from academic and medical studies showing the devastating effects of unsustainable workloads. Real-world connections to coding bug rates, over-specialization, and emotional exhaustion. Tim Urban's TED Talk ("Inside the Mind of a Master Procrastinator") and its ties to the procrastination monkey, panic monster, and unsustainable pace. Why misalignment between expectations and reality (e.g., unrealistic deadlines) breeds toxicity. Radical Candor's "obnoxious aggression" and it can join forces with unsustainable pace to form a diabolical duo. 2. The Positive Results of a Sustainable Pace Building high-quality, continuous delivery without chaos or burnout. The connection between psychological safety, inclusivity, and long-term success in both teams and individuals. Benefits of diverse experiences, low stress, and personal peace from a sustainable pace. Practical strategies to avoid contributing to toxic work or play environments. Stories from youth sports coaching and tech leadership that illustrate how sustainable pace leads to lasting excellence. 3. Actionable Insights for a Better Future How to shift from a culture of "run fast, burn out" to one of balance, productivity, and joy. The systemic changes needed to foster sustainable pace in tech teams and youth sports organizations. Why adopting sustainable practices isn't just about survival—it's about thriving. 🎙️ Why Listen? Whether you're a tech leader, Agile practitioner, parent, or coach, this episode is packed with actionable advice and thought-provoking discussions. Learn how sustainable pace can unlock continuous learning, higher quality results, and a more fulfilling life. ✅ Subscribe to Stay Updated Don't miss other enlightening discussions! Subscribe to the Mob Mentality Show on your favorite podcast platform or YouTube channel: https://www.mobmentalityshow.com 📢 Join the Conversation What’s your experience with unsustainable pace? How have you built or experienced sustainable practices in your work, team, or community? Drop your thoughts in the comments below and let’s talk! Video and Show Notes: https://youtu.be/bTvjoGosBnw

In this exciting episode of the Mob Mentality Show, we sit down with Martin Christensen, a product transformation coach, to explore the pivotal power of mobbing in product discovery. What You'll Learn in This Episode: Mobbing Product Discovery What is Product Discovery? Understand the fundamentals user value, business value, and technical feasibility. Mob Style vs. Solo User Interviews: Learn how mobbing on user interviews enhances insights through diverse perspectives and how it contrasts with traditional solo interviews. The Benefits of Diversity: Discover why the mantra “Mob Anything” unlocks innovation, faster UI/UX iterations, and fewer lines of code while maintaining focus on user experience. Collaboration, Psychological Growth, and Transformation Barriers to New Methods: Dive into the psychological and organizational obstacles that can hinder teams from adopting mobbing or trying new approaches. Adult Development and Teaming: Martin shares insights on how stages of psychological development and life events can break down egocentrism and foster stronger collaboration. The "No Pain, No Gain" Paradox: Can growth happen without trauma? Discover the nuanced relationship between challenges, growth, and maturity in collaborative environments. Impact of Complexity on Happiness: Unpack how the complexity of problems and overall team happiness affect the ability to work effectively as a mob. Why Watch This Episode? If you’re passionate about product development, user experience, or team collaboration, this episode is packed with actionable insights and relatable stories. From understanding the power of mobbing in product discovery to overcoming barriers to psychological maturity in teams, this conversation will leave you inspired to experiment and grow. 🎙️ Don’t miss out! Subscribe to the Mob Mentality Show today to catch this episode and explore other topics at the intersection of innovation, collaboration, and personal growth. 👉 Watch here or on your favorite platform: https://www.mobmentalityshow.com/ Video and show notes: https://youtu.be/IPYXElnuBns

Have you ever wondered who else is adopting mob programming? Or perhaps you’re curious about the diversity of organizations that practice ensemble programming? In this Mob Mentality Show episode, we take a deep dive into the Companies That Mob/Ensemble Program Board, a powerful tool for tracking and sharing insights about organizations, coaches, and educators engaging in mobbing practices worldwide. Join us as we explore the story behind this invaluable resource and its broader implications for the mob programming community. What You’ll Learn in This Episode: Why Track Mobbing? Discover why Chris Lucian started documenting companies and organizations that practice mob programming, beginning with a simple blog post. From Blog to Trello: Learn how this tracking effort evolved from a personal blog to a comprehensive Trello Board, making it easier to manage and share. Uses of the Board: Explore the board’s practical applications, including showcasing the diversity of mobbing practices across countries, industries, and contexts like IoT (Internet of Things), eCommerce, hardware, firmware, software, government, and private sectors. Related Resources: Uncover the connections between this board and other similar initiatives, such as the Software Professional Resources Board and the "We Do TDD (Test-Driven Development)" website. Anecdotal ROI: Hear how this board can serve as anecdotal evidence of the return on investment (ROI) for mob programming from a "just sharing" perspective ( https://justsharing.dev/ ), helping promote its adoption in the software development community. New Categories: Find out about Austin’s updates, which include categories for coaches and professors who practice mobbing. Call to Action: Get inspired to contribute by adding new companies, organizations, or individuals to the board to help grow the global mobbing network. Why This Matters: The Companies That Mob/Ensemble Program Board isn’t just a list—it’s a living resource that reflects the growing diversity and diffusion of mobbing practices worldwide. It’s a tool for saving time, building community, and promoting the Just Sharing mindset. Whether you’re a seasoned practitioner or a newcomer to mobbing, this board helps you connect with others and find inspiration for your own mob programming journey. Get Involved: Want to see the board in action? Check it out here: Companies That Mob/Ensemble Program Board. Subscribe for More Episodes: Don’t miss out on future episodes of the Mob Mentality Show! Subscribe on your favorite platform today: Mob Mentality Show Website. Tune in and discover who else is mobbing—and why it’s transforming the way we work and learn! Video and Show Notes: https://youtu.be/yCB4n-0nxQk

Have you ever wondered why Extreme Programming (XP) isn’t commonly taught in schools? In this engaging episode of the Mob Mentality Show, we dive into this intriguing question brought to us by the mob programming community. 🎓 What We Cover: 1️⃣ A Junior Developer's Dilemma: If schools don’t teach XP, does it mean it’s not critical for your career? 2️⃣ Academia’s Pushback: What are professors saying about XP and unit testing? Is XP seen as incompatible with academic goals? 3️⃣ Systems Thinking in Action: Unpacking how a systems-thinking approach (holistic problem-solving) provides clarity on this issue. 4️⃣ The Runner Analogy: How comparing sprinters and cross-country runners sheds light on coding strategies. 5️⃣ Universities vs. Industry Needs: Are schools preparing students for industry or academic research? What should their goals be? 6️⃣ Degree Confusion: Why students struggle to navigate differences between computer science and software engineering programs. 7️⃣ Niche or Necessity? Why XP, a small sector of the software industry, may not get the spotlight it deserves in schools. 8️⃣ Unit Testing's Lone Survival: Is unit testing finding its way into classrooms, but XP is not? 9️⃣ The “Unknown Unknowns” Problem: What happens when students don’t even realize the value XP could bring to their careers. 🔟 Solutions That Work: Experiments and strategies we’ve used to promote XP in university curricula. 💡 Why This Episode Matters: Maintainability in Code: Discover why maintainability is crucial—not just in industry, but even for academic projects. Handling Resistance: Learn how educators can introduce XP despite opposition from traditional academic mindsets. Spotlighting Success: Shout-outs to universities doing XP right and what others can learn from them. Academia-Industry Collaboration: Insights from years spent on professional committees advocating for XP. 📌 Who Should Watch This Episode? Students: Discover why your curriculum may overlook XP and how to build the skills yourself. Educators: Get inspired to bring XP into your classrooms and navigate institutional challenges. Industry Professionals: Understand the gap between academia and industry, and what it means for hiring new grads. Join us as we explore the challenges and opportunities of integrating XP into education. With actionable insights, engaging analogies, and practical advice, this episode is packed with ideas to spark change. Video and Show Notes: https://youtu.be/CidbB_SBGl0

In this thought-provoking episode of the Mob Mentality Show, we are joined by Ariel Pérez to explore the fascinating intersection of Complex Adaptive Organizations, Organizational Topologies, and the FAST Agile Framework. Together, we dive into the challenges and opportunities of modern software development and organizational dynamics, offering actionable insights for leaders, teams, and anyone navigating complexity in their work. Highlights from the Episode... Complex Adaptive Organizations and FAST Agile: Manufacturing vs. Software Development: Why building the same product repeatedly differs from creating custom software . Complexity Theory in Software Development: How unpredictable side effects shape outcomes and the pursuit of predictability in organizations. Fixed Scope and Fixed Date: Are they real business needs, or just external motivators? What are their long-term impacts on quality and delivery? Theory X vs. Theory Y (management theories): How a leaders' management principles and practices influence autonomy, trust, and collaboration. Dynamic Teams in FAST Agile: The pros and cons of adapting teams dynamically to match work needs versus forcing work into rigid team structures. Story of Transitioning to FAST: A tale of initial resistance to the FAST Agile approach and the eventual embrace of its benefits. Building a Culture of Experimentation and Learning: Experimentation as a Foundation for Innovation: How to test hypotheses in product development and team practices without compromising quality. From Fear to Trust: Encouraging experimentation in new teams or under new leadership while creating safety for bold ideas. Practical Experiments: Implementing small feature flags, A/B testing (comparing two versions in production), and time-limited trial runs to foster innovation. Respect and Radical Candor: Building trust through open communication, mutual respect, and the occasional dose of healthy banter 😅. Risks and Controls: A Never-Ending Game of Whack-a-Mole: Balancing Risk and Control: How risk-heavy environments lead to more controls (e.g., CAB—Change Advisory Board, PR—Pull Request) and the ripple effects of other risks these controls create. Holistic Thinking: Why addressing one risk often introduces others and how to manage risk without stifling agility. Mob Programming as a Solution: Handling emergency changes safely and collaboratively without falling into the trap of excessive gatekeeping. Key Takeaways: Embrace complexity and adapt dynamically to navigate unpredictable challenges. Optimize for learning through experimentation and apply these insights to real-world problems. Avoid control-heavy environments that stifle innovation and agility by thinking holistically about risks. Join us as we unpack these ideas and share strategies to foster a responsive, trust-based culture in your teams and organizations. 🎧 Don’t miss this episode! Subscribe to the Mob Mentality Show on your favorite platform: https://www.mobmentalityshow.com/ FYI: Video and more show notes: https://youtu.be/ghzOSV4waIo

Is some refactored code truly better—or is it just a matter of taste? In this episode of the Mob Mentality Show, we explore the debate: Is some refactoring a subjective preference or an objective improvement? Join us as we dive into the fascinating world of refactoring, where code quality, team dynamics, and even artificial intelligence (AI) come into play. Here’s what we discussed: The Ice Cream Debate: The story of a team/mob navigating a series of refactorings and asking, Are these changes about style, like preferring chocolate over vanilla? Or is there an objective improvement in the code? Cognitive Load, Cyclomatic Complexity, and More: How refactored code impacts key factors like cognitive load (mental effort required to understand code), cyclomatic complexity (a measure of the number of independent paths through a program), readability, and maintainability. Copilot AI's Take: Results of analyzing “before and after” versions of refactored code using Copilot AI (a large language model or LLM trained for coding). Does the AI agree with human developers? Gray Areas vs. Black-and-White Decisions: How much of refactoring is clear-cut improvement versus a matter of debate? Coaching Through Disagreements: Strategies to coach a team through potentially heated refactoring disagreements. Should you stick to principles or let the team run experiments in production against the principles? Decision-Making Tactics: How to align on contentious refactoring decisions. Should you flip a coin, follow a guiding principle, or defer to team consensus? Principles and North Stars: Identifying which coding principles matter most to your team and using them as a decision-making anchor. Dealing with Apathy: How to engage team members who are indifferent to coding principles and quality debates. 7 Habits of Highly Effective People: Applying Stephen Covey’s timeless principles to facilitate productive refactoring discussions and team collaboration. Diversity of Opinion as a Strength: Embracing different perspectives to make your team or mob/team stronger and more innovative. Radical Candor vs. Safe Experiments: Balancing direct feedback with the freedom to experiment—even if it means running tests in production. “Stop the Line” Moments: Deciding when a refactoring disagreement is serious enough to halt progress versus letting safe experiments play out. Whether you’re a developer, team lead, or software architect, this episode is packed with insights to improve your approach to refactoring and team dynamics. 👉 Don’t miss this thought-provoking discussion! Video and Show Notes: https://youtu.be/s2bl7dFAIV0

What happens when teams, codebases, or systems scale beyond their limits? In this thought-provoking episode of the Mob Mentality Show, we tackle this hyperbole: “Is scaling the root of all evil?” We explore how the challenges of scale—in team size, code complexity, and even societal structures—might be the culprit. 💡 Key Discussion Points: Defining Scale Across Contexts: How does scale impact teams, classrooms, codebases, and more? Innovation vs. Scale: Does scaling stifle the spread of good ideas, principles, and practices (e.g., in law, culture, or workplace norms)? Interpersonal Challenges: Why do interpersonal problems grow exponentially in larger groups? Code Quality and Scale: Does a larger codebase inherently lead to lower quality? Focus and Attention: How does scale dilute individual and team focus? What happens to attention in scaled systems? Second-Order Effects: Are rigid systems designed to handle scale unintentionally creating harmful side effects—and even side effects of those side effects? Experimentation and Innovation: How do rigid systems inhibit experimentation, and why does this matter for growth and innovation? Descaling as a Solution: Are the best solutions to scaling problems simply about reducing scale? Inverse Conway Maneuver: Exploring this organizational design concept and its relevance to scaling. Lessons from Coaching: How scaling challenges in youth baseball practices compare to leading software development teams. 🎯 Why You Should Watch/Listen This episode touches on the consequences of uncontrolled growth, from technical issues in software engineering to cultural and organizational challenges. Learn why "descaling" could be the key to improving focus, quality, and innovation in your team or organization. Plus, discover how mobbing (collaborative software development) naturally counters the pitfalls of scaling. 📢 Don’t miss out! Subscribe now on your favorite platform: https://www.mobmentalityshow.com/ Video and Show Notes: https://youtu.be/YLeyRHcI-eI

Join us in this exciting episode of the Mob Mentality Show as we dive deep into the fascinating intersection of mob programming, neuroscience, and team dynamics with the insightful Mike Bowler! Mike brings over a decade of experience facilitating mob programming sessions across hundreds of teams and countless experiments. Whether you're a software developer, team coach, or collaboration enthusiast, this conversation will leave you with actionable insights and inspiring takeaways. 🔍 What We Discuss: - A Different Approach to Facilitating Mob Programming Sessions - The Neuroscience of Psychological Safety and Mobbing - Team Flow States and Brainwave Activity - About Mike Bowler 📢 Don’t Miss Out! Subscribe to the Mob Mentality Show on your favorite platform to learn more about innovative collaboration techniques and team success. 🔗 Find us here: https://www.mobmentalityshow.com Video and show notes: https://youtu.be/okeAxvRggVc