
Show Notes
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
More from The Mob Mentality Show
In this Mob Mentality Show episode, we sit down with Elizabeth Hendrickson and Joel Tossi for a fascinating deep dive into systems thinking, context, and variability. Drawing from the core ideas in their book, Signals and Levers, this conversation explores how mapping systems can transform organizational alignment, shift how leaders invest their resources, and expose the hidden dependencies across seemingly disconnected departments. Elizabeth and Joel share practical insights into how causal loop diagramming, managing side effects, and looking closely at structural constraints can help teams escape the traps of rigid delivery cadences. They discuss how a shared systemic perspective shifts conversations away from isolated department goals and toward true organizational adaptability and collaboration. We dig into: • How systems thinking and causal loop diagramming can map the hidden intersections between software, hardware, sales, and marketing. • The way analyzing system delays and constraints can dramatically shift executive investment strategy to focus where it’s needed most. • Why understanding systemic variability is more important for overall organizational health than merely forcing a predictable delivery cadence. • Moving beyond superficial agile practices to build true, data-driven alignment between cross-functional business leaders. • Real-world stories from the field of immersive learning, dojos, and designing organizations built to adapt organically. Whether you are a software crafter, a product leader, or an executive interested in systems design, this episode offers a practical guide to stepping back, seeing the bigger picture, and finding the true levers that drive high-performing organizations.
In this Mob Mentality Show episode, Chris Lucian sits down with Diana Larsen — co-author of Lead Without Blame, Five Rules for Accelerated Learning, and Agile Retrospectives — to explore what leadership looks like when your team is made of both humans and AI agents. Diana, who came into agile "through the XP door" in the late 90s, argues that a team of some number of humans plus some number of agents is still a complex adaptive system: it has a container, an identity, differences among its players, and exchanges that let it collaborate. The practices we built for human teams — retrospectives, chartering, liftoffs, checkpoints — still apply, if we're intentional about bringing them along. Diana shares her "your agent is your mirror" idea (inspired by the book Your Dog Is Your Mirror): LLMs reflect the behavior they were trained on, and the way we talk to them shapes us too. She types please and thank you to her agents — not for them, but to retain her own humanity. Chris connects this to Theory X vs. Theory Y prompting, his agents.md files with single and double loop learning built in, and his experiments using a frontier model to build a deterministic TDD state-machine MCP server that keeps a less capable model honest — like a senior developer building a process for a junior. The conversation then turns to mobbing with agents and the leadership challenges of this moment. Chris describes how his mobs use "weighing the ox" (wisdom of the crowd) prompting, collaborative prompting, and rotating across four machines, and why the 20-minute agent runtime is a key threshold for context switching. He argues mobbing is more valuable than ever because the typing was never the hard part. Together they discuss the diffusion of innovation, why "Agile is dead" gets declared at every chasm crossing, token maxing as Goodhart's Law taken to its extreme, the Red Queen hypothesis, why no one should have been laid off over AI, and a broken hiring pipeline where a "beautiful" new-grad resume from three years ago now gets 6 callbacks out of 700 applications. We dig into:
In this Mob Mentality Show episode, Chris Lucian sits down with Woody Zuill and James Herr to explore one of the most pressing questions in software teaming today: when AI is writing the code and your team is barely touching the keyboard, where does mob programming fit in? Rather than pushing collaboration aside, James and Woody argue that AI is exposing long-standing bottlenecks more clearly than ever — and that the ensemble is more important now, not less. They share the "AIM Mobbing" perspective they are developing, showing how AI and software teaming unlock the full ensemble by finally removing code as a barrier to participation.
Chris Lucian and Austin Chadwick discuss all things #agile and product development from a #MobProgramming perspective. What if you could decompose every agile method down to its essential building blocks and recombine them for your own specific context? In this episode, Chris and Austin are joined by Aria Omidvar to explore the HEXI method — a framework-agnostic approach to understanding and applying agile, lean, and software craftsmanship practices through physical hexagon objects and collective sense-making. Aria shares his journey from software craftsmanship and clean code, through Scrum and XP, to discovering Dave Snowden's HEXI method and building his own independent "Hexiverse" — a modular knowledge map that spans Software Teaming, Extreme Programming, Kanban, Modern Synthesis, the Agile Manifesto, and more. He unpacks how breaking methods into reusable hexagonal pieces allows teams (and individuals) to see the connections between ideas, surface what is missing, and navigate the overwhelming landscape of agile methods without falling into method wars. We dig into:
In this Mob Mentality Show episode, we join James Herr and Woody Zuill for a one-of-a-kind session James calls the "Hot Sauce Ensemble" — mob programming a video game from scratch in the Godot engine using AI, while eating escalating hot sauces every three-minute rotation. Fair warning to podcast listeners: this episode has a strong YouTube component. If things start sounding chaotic and spicy, that's because they are — jump over to YouTube to see what's happening on screen. James set up the session with Claude Code in VS Code (backed by Amazon Bedrock) and a blank Godot project containing only one asset: a hot sauce sprite generated by ChatGPT. From there, the mob navigated an AI coding agent through a real-time game build — adding player movement, landing explosions, and physics-based bell pepper enemies that scatter when stomped. The enemies were bell peppers specifically because Chris despises them. The hero is hot sauce. The logic is sound. Along the way, James introduced the "plate spinning" technique: opening multiple AI agents in parallel terminals so one prompt cooks while the mob drives another, keeping momentum even when AI responses run long. We dig into: