The Mob Mentality Show

By The Mob Mentality ShowBusiness Technology

The Mob Mentality Show episodes

November 04, 2025 Mob Anti-Patterns Explained: Fly on the Wall, Runaway Driver, and More with James Herr
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
43 min
October 28, 2025 Doing Less, Achieving More: Lean, Clean, and Simple Lessons from Agile Principle #10
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
23 min
October 21, 2025 Effective BDD: Seb Rose and Gaspar Nagy on Real Collaboration, Example Mapping, and Automation Patterns
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
49 min
October 14, 2025 Joshua (Schwa) Aresty on What Remote Teams Can Learn from Mob Programming and Pairing Dynamics
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
46 min
October 07, 2025 Hot Take: The “Code Janitor” Anti-Pattern and Its Impact on Team Collaboration
🧹 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
9 min
September 24, 2025 Agentic AI Slop vs. AI XP Excellence? Iteration, Batch Size, Testing, and the Future of Dev Work
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
29 min
September 15, 2025Open Space Technology for Engineering Leaders: Real Problems, Real Conversations with Amy Dredge, Will Munn, and Mike Clement
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
48 min
September 09, 2025Building Better Products Together: Henrik Ståhl on Mob Programming, MVPs, and Agile Leadership
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
47 min
August 27, 2025Can Control Without Competence Cause Chaos? Agile Principle #11 Discussed
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
11 min
August 18, 2025Growing the Mob and Lessons from 300+ Videos on Mob Programming
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
36 min