The Mob Mentality Show

By The Mob Mentality ShowBusiness Technology

The Mob Mentality Show episodes

May 13, 2025Overrun Navigators, Strong Opinions, and Doc Reading: Prof Ben’s Mobbing Questions from the Trenches
🎙️ 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
50 min
May 07, 2025Football, Trust, and Code: What Retro Bowl Teaches Tech Leaders, Coaches, and Teams
🏈 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
19 min
April 28, 2025How to Split the Impossible: Slicing Stories When the Dream Is Too Big
🎙️ 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
24 min
April 23, 2025How Gemba Walks and Mobbing Reveal the Truth About Your Engineering Org with Phil Borlin
🎙️ 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
47 min
April 14, 2025No Branches?! Ron Cohen Breaks Down Trunk Based Development and Feature Flags (For Real)
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
44 min
April 01, 2025 How Software Prof Ben Kovitz Turned His Class into a Live Coding Mob
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
46 min
March 24, 2025Garrick West on 'Building' Great Developers with XP & Agile plus the Best Debugging
🔥 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
49 min
March 17, 2025 Game Jams & Mobbing: Supercharging Learning, Speed, and Creativity with James Herr
🚀 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
47 min
March 12, 2025 TDD, Misconceptions, and Better Testing with Jason Swett
🚀 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
45 min
February 25, 2025 Agile Principle #12: Continuous Reflection & Adjustment in Mobbing
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
13 min