The Mob Mentality Show

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.

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 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:

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.

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.

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.

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.

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.

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 

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.

What if your team didn't need branches at all?

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 leaves 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.

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.

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:

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.

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.

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:

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.

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.

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.

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.

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

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.

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.

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 does it take to shift from fear to flow when reading and refactoring code? In this episode of the Mob Mentality Show, we dive deep into **"Paradigms of Code Reading"**, exploring the mindsets and techniques that shape how developers approach software understanding. Whether you're navigating legacy code or striving for clean, maintainable designs, this discussion offers actionable insights for individuals, pairs, and mobs alike.   ### What You'll Learn in This Episode:   - **Code Reading Paradigms**: Discover the two ends of the spectrum:     - **Understand Every Line**: Keeping every detail in your head.     - **Extreme Abstraction Zen**: Focusing only on the current module or method.   - **AB Testing in Code Reading**: Insights from live experiments on how pairs and mobs read and understand code.   - **The Role of Trust**: How levels of trust in variable names, methods, and classes influence reading strategies.   - **Overcoming Fear and Skepticism**: What causes developers to ignore method names or distrust the knowledge baked into the code?   - **Cognitive Load and Flow Efficiency**: Learn how reducing cognitive load through small, fast tests can lead to more effective coding sessions.   - **Code Reading Clubs**   - **Coaching Toward Abstraction Zen**: Practical strategies to influence and support others in adopting better reading and refactoring paradigms.   - **Embracing Skeptics**: The value of radical candor, genuine curiosity, and visual aids like diagrams in addressing fear and building trust.   ### Key Takeaways:   - Refactoring starts with trust - Genuine curiosity can replace complaints, transforming how teams collaborate and learn.   - Drawing pictures and visualizing code can unlock new perspectives and improve comprehension.   - Skeptics are not obstacles—they're opportunities for deeper conversations and better design.   Whether you're a seasoned software engineer, a pair programming enthusiast, or new to mob programming, this episode will provide you with practical tools and thought-provoking questions to enhance your coding practice.  

In this episode of the Mob Mentality Show, we dive into our Software Professional Resources Board, a dynamic Trello-based hub designed for software professionals looking to enhance their learning and collaboration in the industry. Join us as we share the board's origin story and our journey in creating a comprehensive resource for everything from Extreme Programming (XP), mobbing, and leadership to cloud infrastructure, agile retrospectives, lean principles, and much more. ### What Makes Our Board Unique? We start by exploring why we chose **Trello** for our resource board and how it has become a cornerstone for organizing, sharing, and discovering knowledge. With its flexibility, Trello enables us to create an easily navigable environment, where resources are not only organized but can also be searched, linked, and explored across various software domains. Our conversation touches on other similar boards we've seen, like our popular "Retrospective Techniques for Coaches, Scrum Masters, and Facilitators" board, as well as spin-offs we've created for specific topics. ### A Variety of Topics Our board covers a broad spectrum of topics that are essential for modern software professionals, including **mobbing**, **refactoring**, **leadership**, **Infrastructure as Code (IaC)**, **agile** practices, and more. With resources curated for both technical and strategic learning, the board has become a go-to reference for articles, blog posts, videos, academic papers, book links, and quotes on various disciplines within software development. ### How We Use the Board for Continuous Learning Discover how we leverage the board not only to organize information but to foster continuous learning. We discuss Chris' “community-supported learning binges” and our process for capturing insightful book quotes and key takeaways, turning the board into a knowledge-sharing powerhouse for software teams and individual contributors alike. ### Refactoring the Mind: Evolving the Board to Stay Relevant Our discussion also delves into the concept of "refactoring my mind by refactoring the board"—an idea about how reorganizing knowledge can improve our mental clarity and adaptability in complex projects. This involves regularly revisiting, reshaping, and expanding board content to reflect the latest insights and trends in software development, keeping it a living, breathing resource for our community. ### The Impact of Public Knowledge Sharing One of the most inspiring aspects of this board is its role in **public knowledge sharing**. We highlight feedback from the community, stories of how others have used the board in their professional journeys, and our own experiences with learning in public. By sharing this resource openly, we invite others to benefit from it, create connections, and add to the body of knowledge that supports software development excellence. Whether you're a developer, coach, Scrum Master, or technical leader, this episode offers valuable insights into how to create and use a resources board to drive personal and team growth. Listen in for tips on organizing knowledge, capturing valuable insights, and using community feedback to make a resource board that truly enhances your software development journey. ### Topics Discussed: - The board's origin story and why we chose Trello - Organizing, searching, and sharing resources in Trello - Similar boards, including "Retrospective Techniques for Coaches, Scrum Masters, and Facilitators" - Variety of topics: mobbing, XP, leadership, IaC, agile, cloud, business, tech, retrospectives, and more - Types of media: articles, blogs, videos, book quotes, academic papers, and beyond - Spin-off boards and community learning sessions - Feedback from the community and lessons for public knowledge sharing **Subscribe on YouTube or your favorite podcast platform to catch this episode and more!** Video and Show Notes: https://youtu.be/GmfWWiIeaVY 

In this Mob Mentality Show episode, we dive into the journey of Jeff “Cheezy” Morgan, a coach in Continuous Delivery (CD) and lean thinking. Known for his role in advocating for CD within companies, Jeff shares how his experiences with software development and his recent shift into the café business have shaped his philosophy on people and just-in-time. This discussion explores how Jeff's approach to Agile and CD evolved, his journey into Extreme Programming (XP), and how mob programming impacted his perspective on teamwork and Continuous Integration (CI).  **Jeff's Agile and CD Journey** We start with Jeff's introduction to Agile, discussing the early days of his career when dev practices didn't include CD and the impact of adopting CD in high-stakes projects like Y2K. Jeff describes how learning from Thoughtworks influenced his views on XP and CD, and how he became an advocate, eventually taking CD to different organizations. He also shares what it was like discussing with Woody Zuill and Llewellyn Falco and reflects on the transformative role mob programming has played in his career. **From Pairing to Mobbing**   For Jeff, mob programming was not initially appealing, but over time it became his preferred approach for helping teams. We explore how mobbing enhances CI, tightens communication, and fosters collective learning. Jeff explains how mobbing enables "just-in-time" discussions that align teams on what to build and how it allows real-time feedback on other team members' learning. Jeff also examines the transition from pairing to mobbing, the challenges of mob programming with CI/CD, and why mobbing helps him “get the whole system in the room” for tackling complex problems. **Quality Without QA?**   We dive into the controversial idea of achieving high quality without traditional Quality Assurance (QA). Jeff opens up about years spent wrestling with the role of QA in Agile/CD environments and shares experiments with “test-infected” developers—who took full ownership of quality. He reflects on the pitfalls of relying on “heavyweight” traditional QA processes and automated tests, which often create lean waste, add handoffs, and introduce brittle, flakey tests. Jeff and hosts Austin and Chris discuss whether “shift left” is merely a shift away from QA, the Deming Red Bead experiment's relevance, and whether there's a happy journey for QA professionals on CD teams. **Applying Lean to Cafés**   Outside the tech world, Jeff has found a second passion—running cafés. We discuss how owning two cafés influenced Jeff's perspective on Lean thinking and Agile principles. From supply chain issues during COVID to needing backup suppliers, Jeff discusses if “just-in-time” challenges in the café world mirror software development. He shares valuable insights about hiring, managing consistent delivery, and applying Lean principles to run a resilient business. Additionally, Jeff and Chris exchange stories on chip shortages and if Lean can help address real-world supply chain issues. **More from Jeff**   Finally, we tackle some big questions: What does DevOps mean in today's Agile world? Should “DevOps” be responsible for shielding organizations from developers? How does Test-Driven Development (TDD) factor into DevOps scripts, and can mobbing help break down silos that traditionally separated devs, ops, and QA? Join us for this wide-ranging conversation with Jeff “Cheezy” Morgan to uncover actionable insights for anyone involved in Agile, CD, DevOps, or Lean. Whether you're in software, QA, or running a small business, this episode is packed with valuable takeaways on quality, learning, and resilience.  Video and Show Notes: https://youtu.be/OJ5d6qLIQRY   

In this episode of the Mob Mentality Show, join us as we delve into "The Discovery of Ignorance in Product Development: Time for a Smarter Way to Deliver Customer Value" with our special guest, Gary Cohen. Drawing on his rich experience across diverse sectors—from government agencies to startups—Gary brings a wealth of insight into optimizing product discovery and delivery for true customer impact.  ### **Key Topics Explored: The Product Discovery and Delivery Intersection** Even if a team is familiar with the 80/20 rule (e.g., where 80% of features go unused), how does it determine the right 20% to deliver? Gary shares strategies to tackle this challenge, advocating for a shift from traditional roadmap fixation to embracing dynamic, continuous discovery that keeps customer value at the forefront. Together, we examine the effectiveness of "strict" roadmap discipline (the practice of adhering to set timelines and objectives) and if it becomes a barrier to true innovation and customer value. We also briefly touch on the FAST framework and its relevance to product discovery, emphasizing how collective discovery through mobbing allows teams to stay closer to evolving customer needs.  ### **The Role of GenAI in Modern Product Development** Is AI is reshaping product discovery? We explore how GenAI can be a collaborative asset for mobs, not only for code development but also for bringing value by uncovering insights into customer behavior and streamlining feature prioritization. We compare "introverted" AI and "extroverted" AI in mob environments and discusses how developing refined AI inquiry skills is key to leveraging AI's full potential. From training mobs in nuanced prompt engineering to using AI to help drive a more lean delivery, we share ways to maximize AI's impact while maintaining expert human oversight.  ### **Bootstrapping Pair and Mob Programming in Individualist Cultures** Transitioning to collaborative programming environments such as pair or mob programming can be challenging, especially in workplaces with a culture of individuality. We offer quick tips on how to bootstrap these methods, from creating a safe space for experimentation to aligning incentives via a peer promotion process. By using context sensitive analogies, how can we influence others in the org to consider jumping into the highly effective world of mob programming? ### **Unpacking Behavioral Expectations: A Smarter Approach to Product Decisions** Beyond the technical, we look at the behavioral side of product monitoring, asking, “What responses do we expect from our users?” Gary emphasizes the importance of behavioral prediction in discovery, cautioning against information bias and providing ways to gauge responses to feature experiments in real-time. We highlight the importance of monitoring usage data and what it reveals about customer engagement—whether a feature elicits a “wow” or a mere “meh.” ### **Takeaways for Product Managers, Engineers, and Innovators** From continuous discovery to leveraging the art of AI prompting, Gary Cohen's insights provide actionable advice for product managers, developers, and cross-functional teams who are ready to rethink their approach to product development and delivery. Whether you're looking to reduce waste, increase customer value, or integrate mob programming and GenAI into your workflow, this episode offers some experiments to try in your journey to achieve product success. Don't miss this engaging discussion filled with actionable strategies, insightful anecdotes, and forward-thinking approaches to innovation!  Video and Show Notes: https://youtu.be/od7E_M9B6gI  

In this exciting episode of the Mob Mentality Show, we are joined by Kyle Griffin Aretae to dive deep into the nuances of Test-Driven Development (TDD) and the crucial concept of "Goal-Centricity" in Agile practices. Kyle breaks down why TDD is so much more than just "test first" and challenges common misconceptions about this widely used development practice. If you're a software developer, Agile enthusiast, or just someone looking to refine your team's development processes, this episode is packed with insights you won't want to miss. We explore why treating TDD as merely writing tests first misses the larger picture and how adopting a broader, more progressive approach can help your team build better, more maintainable software. Kyle shares his thoughts on the primary value proposition of TDD, focusing on **fast feedback loops** and the **refactor step** at least every 5 minutes. He explains how smaller, healthier TDD cycles allow developers to stay nimble and avoid the trap of feedback loops that last 30 minutes or more. Thus, when fast feedback loops with constant refactoring are in place as the foundation, then the "test first" aspect of TDD really shines.  Kyle also sheds light on common pitfalls, such as the misunderstanding of what it means to "do TDD" when developers claim they have 8 unit tests on 50,000 lines of code. We discusses the difference between **Cargo Cult XP (Extreme Programming)** and the real deal, as well as the critical role of **decoupling code** so tests can run in 5 seconds or less.  A key takeaway from this episode is the impact of **social programming**, TDD, and **CI/CD (Continuous Integration/Continuous Delivery) pipelines**. We explain the importance of the "Pipeline First" principle when writing new code. We then dive into Kyle's most controversial take on TDD: the idea that creating a **mini-plan** (a rough roadmap of what to do next) before writing tests might actually be more beneficial than strictly adhering to "test first." This, Kyle argues, leads to more robust code when integrated into strong social programming practices. We also touch on the application of **Maslow's Hierarchy of Needs** to TDD and the importance of satisfying basic development needs (like fast feedback and clean code) before tackling more complex issues. The episode continues with a discussion on the intersection of **Goal-Centricity** and Agile. Kyle questions whether Agile methods are effective without first agreeing on a clear goal. We explore scenarios where goals are unclear or where methods are imposed without understanding the desired outcomes. Kyle shares a fascinating example of a code freeze during "Black Friday" and the unintended consequences of such decisions. We also reference a powerful quote by **Deming**, "A goal without method is cruel," explaining how the opposite can be just as problematic. Throughout the conversation, we dive into the importance of aligning goals between management and development teams, avoiding the common trap of blindly delivering fixed requirements for bonuses, and how real Agile success comes from alignment on solving customer problems, not just ticking off tasks. Kyle emphasizes the need to start with a clear understanding of what you're trying to achieve before applying any method, whether it's Scrum or TDD. Don't miss out on this thought-provoking episode filled with actionable insights on TDD, Agile, and effective software development. Subscribe today and tune in to hear Kyle Griffin Aretae's unique take on how to elevate your development practices! Video and Show Notes: https://youtu.be/S7K8lSibmII  

In this episode of the Mob Mentality Show, we explore the profound concept of "Chesterton's Fence" and how it applies to software development and organizational culture. Chesterton's Fence refers to the idea that before removing or changing a rule, tradition, or practice, one must first understand why it was put in place. We dive into this principle, discuss real-world coding examples, and contrast it with the famous "Five Monkeys Experiment," which explores how behavior and practices can irrationally persist even when the original purpose is forgotten.

In this Mob Mentality Show episode, Chris Lucian and Austin Chadwick dive into the complexities of modern CI/CD (Continuous Integration / Continuous Delivery) pipeline code and IaC (Infrastructure as Code), exploring why these critical components of software delivery often exhibit the same problematic attributes as classic Legacy Code. Drawing inspiration from Michael Feathers' seminal book *Working Effectively with Legacy Code*, they analyze the paradox of cutting-edge DevOps practices turning into technical debt almost as soon as they're written. ### Episode Highlights: - **CI/CD Pipeline Code and Legacy Code Parallels**: Why does so much CI/CD and IaC code resemble legacy code? Despite being crucial for continuous delivery and automation, CI/CD pipelines can become fragile, difficult to change, and filled with technical debt if not handled carefully. Austin and Chris discuss why this phenomenon is so common and what makes the codebases for CI/CD pipelines especially prone to these issues.    - **“Edit and Pray” vs. TDD Confidence**: Do your CI/CD changes feel like a roll of the dice? Chris and Austin compare how the lack of test-driven development (TDD) practices in CI/CD code leads to “edit and pray” scenarios. They discuss the confidence that TDD brings to traditional application development and how applying similar principles could reduce fragility in CI/CD code. - **The Pitfalls of YAML in IaC**: Is the problem inherent to YAML? The hosts explore whether the complexity of YAML syntax and configurations is the root cause of the brittleness often found in IaC. They provide real-world examples of IaC configurations that suffer from high cyclomatic complexity—making them feel more like full-blown applications rather than simple configuration files. - **Fear of Change in CI/CD and IaC**: Why are developers often afraid to modify CI/CD pipeline code or IaC? Chris and Austin highlight the psychological aspects of fragile infrastructure—where fear of unintended consequences and lack of fast feedback loops result in slower iterations and more bugs. They explore why these codebases are often re-written from scratch instead of extended and safely enhanced. - **Reducing Fragility through Experiments**: The episode features a recent experiment where CI/CD pipeline code was developed in Python using TDD and separation of concerns. This case study reveals the pros and cons of less YAML and a shift towards more code-based "configurations." Could this approach be a solution to reducing brittleness in IaC and pipelines? - **A World Without Brittle Pipelines?**: Imagine a world without fragile pipelines and brittle configuration files. Chris and Austin discuss strategies to move towards more resilient infrastructure and how teams can focus on improving feedback loops, reducing complexity, and enabling safer, faster CI/CD iterations. Join Chris and Austin as they explore these and other crucial topics that are impacting DevOps teams around the world. Whether you're struggling with high bug rates in your pipelines, slow feedback loops, or simply want to better understand how to manage the complexity of modern infrastructure, this episode is for you! Video and Show Notes: https://youtu.be/3Cs-j055b9g