The Mob Mentality Show: Recent Episodes
The Mob Mentality Show
Chris Lucian and Austin Chadwick discuss all things agile and product development from a mob programming perspective.
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 adds insights from his own agentic workflow experiments at Hunter Industries — running multiple agents in parallel in a "plate spinning" pattern, using a mutation testing agent running continuously in the background, and crafting large prompts designed to complete 2+ hours of work autonomously. The group also explores how context window management, modular skills files, and code generators solve the consistency problems that make many developers skeptical of AI-generated code. Woody shares his honest experience with LLM reliability and the importance of having strong verification mechanisms in place — including unit tests used as guardrails rather than as a test-driven design tool.
The episode closes with a rich reflection on this chaotic and exciting moment in software history. Woody compares it to the earliest days of programming: discovery happening in real time, the ground shifting underfoot, and ideas growing faster when shared. All three guests agree that teams who use AI as a highly amplified collaborative learning environment will be best positioned to thrive — and that the skill of giving high-level intent, central to mob programming, is the same skill that unlocks the most from an AI agent.
We dig into:- How AI accelerates the exposure of queuing and bottlenecks throughout the entire software development lifecycle.- Why removing code as a barrier enables product owners, UX designers, and testers to join the ensemble full-time.- The "plate spinning" pattern: running multiple AI agents simultaneously to eliminate wait time for the mob.- Chris's agentic kata practice: 3 months of prompts crafted to run 2+ hours without errors, and what he learned.- Context window management: keeping LLM context at ~50% capacity using tiny instruction files and modular skills files.- Using AI to write code generators (not production code directly) for deterministic, consistent output.- Unit tests as guardrails for AI-generated code rather than as TDD design tools.- Woody's experience with LLM limitations — hardcoded outputs, forgotten context, and the need for verification.- The high-level intent parallel: how directing an AI agent mirrors the navigator/driver model in mob programming.- Why this chaotic period in software development is the most exciting in decades — and why teams will navigate it better than solo developers.
Podcast Episode…Apple: https://podcasts.apple.com/us/podcast/the-mob-mentality-show/id1485950034Spotify: https://open.spotify.com/show/01npjdd1VRiNqw1RZ8aB5g?si=607de4da208a425cPodBean: https://mobmentalityshow.podbean.com/Amazon: https://music.amazon.com/podcasts/7a695161-1857-466d-83ca-d9a75161823b/the-mob-mentality-show
References…Woody Zuill's LinkedIn: https://www.linkedin.com/in/woodyzuill/James Herr's LinkedIn: https://www.linkedin.com/in/james-herr/Software Teaming / Mob Programming Resources: https://woodyzuill.com/
Thanks to G-SLiK (https://soundcloud.com/g-slik) for the intro and outro music.
Chris Lucian and Austin Chadwick discuss all things #agile and product development from a #MobProgramming perspective.
Chris Lucian is the Director of Software Development at Hunter Industries and a founder of mob programming. https://www.chrislucian.com/p/chris-lucian-biography.html
Austin Chadwick is a Mob Programmer at Hunter Industries and is a passionate agilist and craftsman with experience in several roles (e.g. coach, developer, tester, scrum master, business analyst). https://www.linkedin.com/in/austin-chadwick-3a58151a4/
We would love your feedback and ideas for future episodes! Please add comments to the video or reach out to us on Twitter ( https://twitter.com/mob__mentality & https://twitter.com/ChristophLucian ).
All statements and opinions expressed by Chris, Woody, James, and Austin are solely their own and do not represent the views of any company. Chris and Austin are just sharing and not recommending ( https://justsharing.dev/ ).
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:
- What the HEXI method is and how Dave Snowden and Nigel Thurlow introduced it via Scrum.org
- How Aria independently adapted HEXI to create a Hexiverse for software teaming and mob programming
- Why decomposing methods into building blocks enables recombination for any specific context
- The spatial design choices behind the Hexiverse — and why dotted hexagons signal a concept shared across sets
- How Alistair Cockburn validated the Agile Manifesto hexiset (and why that meant the world to Aria)
- The learning journey metaphor of islands growing large enough to connect — and how the Hexiverse accelerates that
- Why "nice" doesn't cut it in high-collaboration environments — and how kindness, consideration, and respect offer a deeper model
- The "turn up the good" retrospective format and why it flips the traditional improvement lens
- How the Hexiverse serves both as a personal learning quest and a potential onboarding tool for teams new to agile methods
- Aria's call to action: check the original HEXI sources, play with the physical kits, and consider building your own Hexiverse
Scaling Complex Systems by Building on Agile Frameworks with Dave Snowden and Nigel Thurlow: https://youtu.be/AEf1BCffimA
Aria's Hexiverse on Miro: https://miro.com/app/board/uXjVKv84GGU=
The Hitchhiker's Guide to Hexiverse on Medium: https://medium.com/@omidvar.aria/list/the-hitchhikers-guide-to-the-independent-hexiverse-fe509a7c46f8
The Hitchhiker's Guide to Hexiverse on LeanPub: https://leanpub.com/HG2H
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:
- How "Hot Sauce Ensemble" combines traditional mob rotations with escalating spicy food — and why it works as a team-building format
- Using Claude Code in VS Code with Godot to build a playable game from a blank project in real time
- The plate spinning technique: running multiple AI coding agents in parallel terminals to maintain flow
- Why the goal should be "effective," not "productive" — and how mob programming and AI tools both support that shift
- How AI procedurally generates game art assets (bell pepper sprites built from polygon shapes and shading) without any image generation tools
- Navigating an unfamiliar codebase and engine as a mob, using an AI agent as the technical guide
- What happens to your prompting quality when habaneros and The Last Dab are involved
- Hot sauce as a hero, bell peppers as villains: designing game mechanics around personal taste (literally)
If you've ever wondered what mob programming looks like when applied to game development, AI-assisted coding, and competitive spice tolerance all at once, this episode delivers all three simultaneously — with physics.
References… James Herr's LinkedIn: [PASTE LINK] Woody Zuill's LinkedIn: [PASTE LINK] Godot Engine: https://godotengine.org/ Claude Code: https://www.anthropic.com/claude-code Mobster (mob timer): [PASTE LINK]
Hot Sauces Featured… James: Hot Ones Apricot Sauce (#7), Hot Ones The Last Dab (#10) Woody: Taco Bell Hot Sauce, ~3 lbs pickled jalapeños (stuffed in a burrito) Chris: Fishwife Albacore in Spicy Olive Oil, Oni Yuzu Lemon Hot Sauce (Japan), Marie Sharp's Carrot & Habanero (2-habanero, 4-habanero Blazing Hot, and 5-habanero BEWARE) on a PB&J
Thanks to G-SLiK (https://soundcloud.com/g-slik) for the intro and outro music.
Chris Lucian and Austin Chadwick discuss all things #agile and product development from a #MobProgramming perspective.
Chris Lucian is the Director of Software Development at Hunter Industries and a founder of mob programming. https://www.chrislucian.com/p/chris-lucian-biography.html
Austin Chadwick is a Mob Programmer at Hunter Industries and is a passionate agilist and craftsman with experience in several roles (e.g. coach, developer, tester, scrum master, business analyst). https://www.linkedin.com/in/austin-chadwick-3a58151a4/
We would love your feedback and ideas for future episodes! Please add comments to the video or reach out to us on Twitter ( https://twitter.com/mob__mentality & https://twitter.com/ChristophLucian ).
All statements and opinions expressed by Chris and Austin are solely their own and do not represent the views of any company. Chris and Austin are just sharing and not recommending ( https://justsharing.dev/ ).
Join the Mob Mentality Show for a stimulating conversation with Kenny (Baas) Schwegler, co-author of Collaborative Software Design, as we explore the intersection of software architecture, team collaboration, and organizational culture. In this episode, we uncover how collaborative software design and Domain-Driven Design (DDD) transform software delivery from a siloed, top-down process into a shared problem-solving experience that integrates business, engineering, and user perspectives to get all the data on the table.
Kenny shares practical strategies for running collaborative modeling sessions, including EventStorming, example mapping, and guerrilla modeling. Learn how to engage stakeholders and developers in the same room, foster shared understanding, and evolve systems iteratively while navigating complex organizational dynamics. Whether you’re designing greenfield systems or improving brownfield applications, these techniques empower teams to reduce miscommunication, avoid groupthink, and make better design decisions faster.
We also dive into the cultural and systemic challenges that impact software delivery, including implicit hierarchies, patriarchal structures, and unspoken decision-making rules. Discover how amplifying quiet voices, balancing power dynamics, and creating psychologically safe environments directly improve software outcomes. Kenny explains how effective collaboration goes beyond tools and patterns—it’s about shaping a culture where diverse expertise is actively leveraged and trade-offs are surfaced transparently.
Key takeaways from this episode include:
- How collaborative software design bridges business understanding and technical feasibility.
- Practical methods to introduce DDD, even in non-collaborative environments.
- Techniques to iteratively discover, model, and implement solutions in complex domains.
- Strategies to neutralize hierarchy and amplify underrepresented perspectives in decision-making.
- Insights on integrating team autonomy, Team Topologies principles, and flow-based development for continuous improvement.
This episode is essential for software architects, product leaders, developers, and anyone invested in high-performing, collaborative teams. Gain actionable insights on designing software as a collective endeavor, aligning stakeholders, and creating systems that support innovation, adaptability, and inclusion.
Video and Show Notes: https://youtu.be/Mqbm2kwpsHo
What happens when Agile, Extreme Programming, and Test-Driven Development meet a world dominated by hardware, graphical programming, and binary artifacts?
In this episode of the Mob Mentality Show, we’re joined by Sam Taggart to explore what it really takes to introduce modern software engineering practices into environments like LabVIEW, embedded systems, and industrial software teams. These are contexts where deployment can be slow, feedback loops can be expensive, and “just refactor it” feels like it is not an option.
We dig into why applying XP, TDD, mob programming, and continuous integration looks very different when your software is tightly coupled to physical devices, firmware, and test equipment. Sam shares practical insights on adapting Agile ideas so they actually work in hardware-constrained environments, rather than forcing patterns designed for web apps onto teams that live in a very different reality.
A major theme of the conversation is change. How do you sell new engineering practices to skeptical teams? How do you introduce better ways of working without triggering resistance or fear? And how do you help organizations move forward when legacy code, specialized tools, and long-established habits get in the way?
We also spend time on a deceptively simple but critical idea: knowing what “good” looks like. From testing strategies and code quality to team collaboration and delivery confidence, having a clear vision of good engineering makes it far easier to experiment with better practices and avoid cargo-cult Agile.
This episode is especially relevant if you work with LabVIEW, embedded systems, firmware, industrial or hardware-adjacent software, or if you’re leading teams where Agile adoption feels harder than the books make it sound.
Topics include:
- Applying TDD and XP in graphical, binary, and legacy codebases
- Mob programming and collaboration in hardware-heavy environments
- Continuous integration and delivery when deployment is constrained
- Introducing Agile ideas without alienating experienced engineers
- Reducing risk while improving feedback and quality
- Helping teams see and aim for better engineering outcomes
Video and Show Notes: https://youtu.be/Kxzn_2aYMIM
What actually separates a fully engaged mob from one that feels flat, quiet, or stuck? And why does that difference matter far beyond team morale?
In this episode of the Mob Mentality Show, we explore how team engagement directly impacts software delivery, learning, and long-term sustainability. Drawing from real mob programming experiences—ranging from high-energy, large-group collaboration to small teams struggling with disengagement—we unpack the patterns behind why engagement rises or fades.
Rather than offering a one-size-fits-all playbook, this conversation treats engagement as a systems and complexity problem. We discuss how engagement shows up differently in quiet vs. loud mobs, how personal context and learning overload can influence participation, and why disengagement is often a signal—not a character flaw.
You’ll hear practical ways facilitators and teams can probe, sense, and respond when engagement drops, including:
- The difference between intrinsic and extrinsic motivation in mob settings
- When small format changes help—and when they’re only a temporary band-aid
- How psychological safety affects learning, contribution, and retention
- Techniques for surfacing hidden confusion without negatively calling people out
- Why repeated work and lack of progress quietly drain motivation
- When disengagement points to deeper systemic or environmental issues
We also connect engagement to outcomes leaders care about: flow, learning speed, delivery quality, and business impact. This isn’t about forcing fun or “rah-rah” energy—it’s about creating conditions where people want to contribute, can contribute, and see the value of innovating together.
Whether you’re a developer, facilitator, tech lead, or engineering manager, this episode offers concrete signals to watch for and experiments to try—while respecting the complexity of human systems.
If you’ve ever wondered why one mob feels alive and another feels exhausting, this conversation can help you see what’s really going on beneath the surface.
Video and Show Notes: https://youtu.be/P0-PWstQhqk
Escape Room Style Mobbing is a real collaboration pattern many teams run into, even if they do not have a name for it yet. In this episode of the Mob Mentality Show, we break down the spectrum between two very different mobbing modes: fast, noisy, interruption-heavy “escape room” mobbing and the quieter, deliberate, research-first approach some teams rely on instead.
Across the conversation, they share concrete examples from dozens of mobs they have been part of over the years. You will hear what actually happens in high-energy mobs that optimize for speed, flow, and rapid experiments. You will also hear what shifts when a team leans into slow, deep thinking, deep learning, cautious change, and single-threaded communication.
The episode digs into the real tradeoffs:
- When interruptions accelerate discovery and when they create friction or waste
- Why some teams thrive in a “pull everyone in now” environment while others feel overwhelmed or blocked by the noise
- Why the same people might switch styles depending on context, psychological safety, or the kind of problem they are solving
You will also hear how teams manage learning in each mode, how business expectations can map with the mob’s behavior, how different personalities respond to high-octane collaboration, and why both styles can be healthy when used intentionally in the right context rather than by accident.
If you work on Agile teams, practice Mob Programming, care about delivery flow, or you simply want to understand why your team’s collaboration energy swings from chaotic to quiet, this episode gives you language and mental models you can use right away.
FYI: Video and Show Notes: https://youtu.be/kZ9yH5Fibn4
In this Mob Mentality Show episode, we sit down with Abid Qureshi for a candid and eye-opening look at what Agile Software Development was meant to be versus what the industry turned it into. If you’ve ever wondered why “Agile” feels bloated today, why teams still struggle to adapt quickly, or why universities are still teaching outdated models like Waterfall, this conversation will hit home.
Abid shares his perspective on why the original movement focused on lightweight methods, experimentation, and uncovering better ways of developing software. He explains how the software industry drifted toward heavyweight processes and off-the-shelf frameworks, and what gets lost when organizations treat Agile as a set of fixed best practices (independent of a code context) instead of an ever evolving software craft. He also challenges long-held assumptions about technical excellence, design, and the true sources of agility in modern software development.
We dig into:
- The contrast between early agile software development and what “Agile” represents today.
- Why the title “Agile Manifesto” is misleading and what the document was actually about.
- How advances in technology, object-oriented programming, automated testing, and continuous integration made genuine agility possible.
- Why real adaptability comes from reducing the cost of change, not adding more process.
- The danger of scaling up bureaucracy instead of scaling down and improving engineering practices.
- How non-technical contributors sometimes unlock unconventional, high-value ideas that technical experts overlook.
- Why many higher education programs still teach waterfall-style thinking and how that hurts new developers entering the industry.
- The missed opportunity for universities to lead innovation in software development instead of echoing outdated industry norms.
If you care about XP, Lean thinking, software craftsmanship, technical excellence, or getting back to the heart of agility, this episode offers a practical and refreshing reset. Abid’s stories and insights challenge the assumptions that hold teams back and point toward a more grounded, engineering-driven approach to modern software development.
Video and Show Notes: https://youtu.be/nJI-veSJdkQ
What happens when you combine daily mini-retrospectives, Test-Driven Development in absurdly small steps, and Chess Clock Mobbing? You get a radically different iteration on collaboration, continuous improvement, and extreme programming—and that’s exactly what we explore in this episode of the Mob Mentality Show with guests Kevin Vicencio and Alex Bird.
Kevin and Alex are on a team who didn’t just mob the canonical way—they experimented with variations and discovered something that seems faster, tighter, and even more collaborative in many ways. From refining how teams use retrospectives to guide daily improvements, to pioneering a new high-intensity form of teaming called “Chess Clock Mobbing,” their approach is relentless in its pursuit of learning and team flow.
In this conversation, we dig into:
- How daily retros and real-time feedback can evolve your team culture fast
- Why working in smaller TDD steps can paradoxically lead to faster results
- The mechanics and mindset behind Chess Clock Mobbing
- “Evil TDD Ping Pong” as a way to level up test design and shared understanding
- Building a culture of trust, safety, and continuous experimentation
- Techniques for maintaining momentum, engagement, and learning in remote-first dev teams
- The power of absurdly small experiments and the compounding effect of micro-improvements
Whether you’re an Agile coach, XP practitioner, software engineer, or just curious about pushing the boundaries of collaborative development, this episode delivers deep insights, real practices, and actionable takeaways you can try with your team tomorrow.
📌 Don’t forget to like, comment, and share if this episode sparked an idea or a conversation!
Video and Show Notes: https://youtu.be/w3vvpJ3VKew
In this lightning-talk-style Mob Mentality Show episode, Austin Chadwick takes you through his real-world evolution from clunky, waterfall-style processes to fully cranked-up Extreme Programming (XP)—a journey defined by failures, breakthroughs, and a relentless pursuit of clean, test-driven code.
Starting in a rigid, process-heavy dev shop where a typo fix required presidential-level approvals, Austin shares how years of stagnation, big batch releases, and public demo disasters (including rogue robots) led him to ask the big question: What if we actually did Extreme Programming all the way—no compromises?This episode digs into:
- Why doing half of XP might be worse than doing none
- The hidden cost of tolerating just “one bug”
- What daily delivery and value-first thinking really look like in practice
- Experiments on how to survive (and thrive) when your dev culture thinks you’re “too extreme”
- The real tradeoffs of turning XP, TDD, and refactoring up to volume level 11
- When agile and XP becomes a “cargo cult”
- Lessons from being one of the lone voice for clean code in an organization stuck in the middle
Alongside co-host Chris Lucian, Austin reflects on the resistance many developers face when advocating for full adoption of XP practices—like pair and mob programming, evolutionary design, continuous delivery (CD), test driven development (TDD), and bug-free codebases. They also explore how to escape local optima by introducing meaningful “mutations” to your dev environment and culture.
Whether you're a software engineer tired of firefighting and regressions, a team lead wondering why your “agile” isn’t working, or a practitioner curious about what it means to really commit to Extreme Programming, this conversation pulls no punches.
👍 Like the episode? Hit the thumbs up, drop a comment, and share with someone who’s still debating whether TDD is “worth it.”
Video and Show Notes: https://youtu.be/AKXRGmSYgWs
In this episode of the Mob Mentality Show, we sit down with James Herr from Flexion to explore the dark side of mob programming — the anti-patterns that quietly erode collaboration, learning, and flow in your team.
From the “Fly on the Wall” who silently observes but never joins in, to the “Runaway Driver” who takes control and goes rogue, and the “Knee-High Navigator” who dictates every keystroke, these relatable scenarios shine a light on what can go wrong during mob or ensemble programming sessions — and, we share some potential experiments ideas to address them.
James shares real-world insights from years of ensemble experience, walking through the subtle behaviors and team dynamics that lead to these anti-patterns. The discussion moves beyond surface-level symptoms to uncover psychological safety, learning theft, and communication habits that make or break mobbing success.
You’ll learn:
- What causes common mob programming anti-patterns — and how to recognize them early
- Practical techniques to help newcomers integrate smoothly without being overwhelmed
- How to use “strong-style” collaboration and mini-retros to restore balance in a team
- When to “let it cook” vs. when to intervene to prevent runaway drivers
- How to cultivate high-level navigation and reduce micromanagement in coding sessions
- Why “white-glove” onboarding for visitors and new mobbers accelerates learning and trust
- How naming patterns improves team reflection, vocabulary, and psychological safety
This episode dives deep into the human side of technical collaboration, blending agile principles, systems thinking, and lived experience from teams practicing mob and ensemble programming every day.
Whether you’re a developer, product owner, engineering leader, or agile coach, you’ll walk away with practical strategies to identify and correct these patterns — before they derail your team’s effectiveness.
Video and Show Notes: https://youtu.be/NxLor73Rgds
Can simplicity be your team’s most powerful productivity tool?
In this episode of The Mob Mentality Show, we explore Agile Manifesto Principle #10: “Simplicity—the art of maximizing the amount of work not done—is essential.”
This isn’t abstract Agile theory — it’s real-world stories and lessons from software teams who’ve learned how to cut waste, focus on what matters, and deliver more by doing less. We share hands-on examples from their work in Mob Programming, Extreme Programming (XP), and Lean Thinking, unpacking how simplicity shows up in everyday team decisions.
🎯 In this episode, you’ll learn:
- When saying “no” isn’t the answer — and how to say “yes, and…” instead with...
- How small automations can save time, build trust, and remove repetitive work
- The power of reducing batch size to get faster feedback and higher quality
- What the “nice-to-have bag” taught us about ruthless prioritization
- How profitability can actually hide inefficiency and technical waste
- Why focusing on the 20% of work that drives 80% of value keeps teams sharp
- How to stay lean, adaptable, and resilient — even when things feel “comfortable”
- What "gold-plating" really means in the context of software development
This conversation hits the intersection of Agile mindset, team collaboration, and developer culture. It’s packed with takeaways for engineers, team leads, and product owners who want to create sustainable, high-performing teams without falling into overproduction or other lean wastes.
💬 Whether you’re scaling a software product, improving team flow, or rethinking your backlog, this episode helps you bring clarity and simplicity to your workflow — so your team can do less, achieve more, and deliver what truly matters.
Video and Show Notes: https://youtu.be/W9t4GOU4Vmk
In this episode of The Mob Mentality Show, we sit down with Gáspár Nagy and Seb Rose, two highly respected voices in the Behavior-Driven Development (BDD) community, to discuss their brand-new book, Effective Behavior-Driven Development, published by Manning Publications.
Seb and Gáspár share their hard-won insights from over 15 years of helping teams adopt BDD the right way—focusing not just on tools or syntax, but on real collaboration, shared understanding, and sustainable automation practices.
You’ll learn how Example Mapping helps teams uncover hidden assumptions, why Automation Patterns matter for long-term maintainability, and how the Effective BDD book brings together their previous works on Discovery, Formulation, and Automation into one cohesive guide for practitioners.
The conversation covers:
- What “effective” BDD really looks like in modern agile teams
- Why collaboration—not tooling—is the true heart of BDD
- How Example Mapping accelerates shared understanding and reduces rework
- What automation patterns many test suite needs (and what pitfalls to avoid)
- How to write maintainable, meaningful, and human-readable scenarios
- Insights from their journey creating Effective BDD and its roots in the patterns community
- Real-world lessons from decades of coaching, training, and hands-on development
Whether you’re a developer, tester, product owner, or agile coach, this episode will help you see BDD not as a buzzword, but as an actual way to turn up the good on collaboration and quality for software delivery.
Video and Show Notes: https://youtu.be/0Yf8oPPKlv8
In this episode of The Mob Mentality Show, hosts Chris Lucian and Austin Chadwick sit down with Joshua (Schwa) Aresty to explore how remote teams thrive through communication, collaboration, and creativity in modern software development.
Together, they unpack three powerful and practical topics shaping the future of agile engineering:
🔹 Remote Work Communication Patterns
What makes remote collaboration work — and what breaks it? The discussion dives into real patterns that distributed teams can adopt to communicate more clearly, stay aligned, and maintain momentum without burnout. Learn how to balance synchronous and asynchronous teamwork for maximum flow and productivity.
🔹 Mobbing vs Pairing
What’s the difference between mob programming and pair programming in practice? The conversation breaks down the strengths and trade-offs of each approach. Discover when a mob or a pair works best, how to transition between the two, and how these methods can build a culture of shared learning, faster feedback, and higher-quality code.
🔹 Voice Coding and Accessibility
Joshua brings unique insights into coding by voice — an approach that challenges traditional ideas of how developers write code. Hear how voice coding improves ergonomics, accessibility, and inclusivity in software engineering. This segment highlights how diverse workflows and adaptive tools can unlock new levels of creativity and collaboration.
Whether you’re an agile practitioner, developer, team lead, or engineering manager, this episode delivers practical takeaways you can apply immediately:
- Strengthen communication in remote or hybrid teams
- Choose between pairing and mobbing effectively
- Foster inclusive, accessible engineering environments
- Improve team learning and knowledge sharing through ensemble programming
🎧 Tune in to learn how collaborative coding techniques, like mobbing and pairing, can transform not just how software is written — but how teams connect, learn, and grow.
Stay connected and join the conversation with the Mob Mentality community — where we explore the people, practices, and patterns that make software development more human, sustainable, and effective.
Video and Show Notes: https://youtu.be/vBGwXhTFUkI
🧹 In this episode of the Mob Mentality Show, we quickly cover the “Code Janitor” anti-pattern — a hidden trap that can quietly undermine team performance. While teams are often formed to maximize collaboration, learning, and flow, certain team dynamics can introduce dysfunctions. The “Code Janitor” role is one of them.
What exactly is the "Code Janitor" anti-pattern? It happens when one person slips into the role of silently cleaning up after the team — fixing formatting, organizing files, refactoring, tidying the codebase, or generally taking on tasks that would be better shared by the whole team. On the surface, it may look helpful, but in reality, it can limit transparency, reduce shared ownership, and end up being "too little, too late." This episode explores why this happens, how to recognize it, and most importantly, what options teams have for mitigation.
Listeners will hear hot takes on:
- How small, well-intentioned behaviors can spiral into anti-patterns
- Why the janitor role reduces the learning opportunities for the whole team
- Strategies to keep mob cleaning collaborative and balanced
- Tips for fostering healthy communication and shared responsibility
- How leaders and team members can encourage practices that improve flow instead of hiding work
- Is the “Code Janitor” anti-pattern the lesser of two evils and therefore permissible in some situations? 😅🧼🧽
Whether you’re new to mob programming or a seasoned practitioner, this quick episode is a reminder that even small patterns can have big impacts on engineering culture and team productivity. If you’re passionate about agile software development, software craftsmanship, and continuous improvement, this episode will give you a new lens on how teams work together and how to spot warning signs before they hurt you.
Video and Show Notes: https://youtu.be/rckIiSodfyY
In this episode of the Mob Mentality Show, we dive into the growing tension between the fast rise of Agentic AI systems and the foundational principles of Extreme Programming (XP) and Lean Software Development. As more teams experiment with multi-agent LLM orchestrators like Claude, GPT-4, and others, does the risk of generating untested, low-quality "AI slop" increase—unless guided by tight feedback loops, small batch sizes, and real tests?
We ask:
- Can Agentic AI truly support Agile and XP practices—or is it working against them
- Are we moving toward AI-driven productivity or just automating chaos faster?
- What practices can keep teams grounded as tools grow more autonomous?
Join hosts Austin Chadwick and Chris Lucian as they explore:
- The difference between AI-assisted XP excellence and Agentic AI slop
- Real-world dev experiences using multi-agent architectures
- How to apply small iterations, pairing/mobbing, and test-first thinking in AI-augmented workflows
- The pitfalls of Agentic orchestration without lean guardrails
- Why mob programming and XP might be the missing link in managing AI complexity
- Tips for maintaining engineering rigor in a world of AI copilots and task runners
If you're experimenting with AI in software teams—or trying to balance automation with craftsmanship—this conversation is packed with insights, practical takeaways, and a few strong opinions.
📢 Share this episode with anyone navigating the messy intersection of AI tools and solid software practices.
Video and Show Notes: https://youtu.be/efW8eaOGL28
In this episode of the Mob Mentality Show, Chris Lucian is joined by Amy Dredge, Will Munn, and Mike Clement to dive deep into how Open Space Technology (OST) is transforming the way engineering leaders learn, connect, and solve real-world challenges together.
Whether you're a Staff+ engineer, an engineering manager, or a tech leader looking for meaningful growth, this episode uncovers how OST creates space for peer-to-peer learning that’s spontaneous, high-impact, and deeply human.
We explore:
- The Engineering Leadership Summit — what it is, why it matters, and how it's unlike traditional conferences.
- How Open Space Technology empowers attendees to shape their own agenda and focus on the most pressing leadership challenges.
- The shift from passive presentations to active conversations among experienced engineering leaders.
- Lessons learned from hosting and attending open space events — from hallway chats to high-trust collaboration.
- How tools like GatherTown help replicate the spontaneity of in-person connection in a remote world.
- Why this format resonates deeply with Staff+ and senior engineering leaders seeking authenticity, relevance, and practical insight.
We also compare remote vs. in-person open space events, dig into accessibility, and share actionable tips for running your own internal or external open space sessions inside engineering orgs.
🎧 This is a must-listen for anyone serious about growing engineering culture, building leadership communities, and fostering real, unscripted learning.
💬 What’s your experience with open space formats in tech? Drop a comment or DM us on social.
📌 Topics Covered:
- Open Space Technology in Engineering
- Staff+ and Engineering Manager Peer Learning
- Engineering Leadership Summit Preview
- GatherTown for Remote Events
- Community Building in Tech
- Agile Leadership in Practice
- Unconference vs. Traditional Conferences
FYI: Video and Show Notes: https://youtu.be/domldsgqkDs
In this episode of the Mob Mentality Show, we sit down with Henrik Ståhl, a product manager and advocate for collaborative software development, to explore how mob programming, MVPs, and agile leadership can reshape the way teams build products.
Henrik shares a unique product manager perspective on mob programming—why it’s more than just a coding practice and how it becomes a powerful tool for communication, knowledge sharing, and true collaboration across teams. We dive into what happens when product managers actively join mob sessions, the unexpected benefits for decision-making, and how it reduces waste and rework.
We also tackle one of the most misunderstood concepts in product development: the MVP (Minimum Viable Product). Henrik explains why many teams fall into the trap of either shipping low-quality “minimums” or overengineering “full products,” and what viable should really mean. You’ll hear insights on how sustainability, scalability, and learning fit into the MVP conversation—whether you’re at a large enterprise or an early-stage startup.
Finally, we unpack the infamous phrase “Move Fast and Break Things.” Henrik reframes the idea, showing how moving fast doesn’t mean sacrificing quality or creating chaos, but instead building the right contingency plans, embracing adaptability, and ensuring that speed leads to sustainable outcomes rather than long-term failures.
If you’ve ever wrestled with questions like:
- How can product managers contribute directly in mob programming?
- What does “viable” really mean in MVP?
- How do you balance moving fast with building lasting, maintainable products?
- How can teams avoid rework, miscommunication, and wasted effort?
…this episode is packed with practical takeaways and perspectives you can use right away.
🎙️ Listen in to learn how to build better products together—with less blame, fewer silos, and more shared ownership.
📌 Topics Covered:
- Mob programming from a product manager’s perspective
- The real meaning of MVP and why “Minimum Viable Whatever” fails
- Rethinking “Move Fast and Break Things” for sustainable speed
- Communication, collaboration, and continuous improvement in agile teams
- Knowledge sharing, reducing waste, and eliminating silos
Video and Show Notes: https://youtu.be/JCZcJ6xT7-8
In this episode of the Mob Mentality Show, we explore Agile Manifesto Principle #11: “The best architectures, requirements, and designs emerge from self-organizing teams.”This principle often sparks debate. Can teams really create great architecture and design without top-down control? Can autonomy be granted when the team isn’t ready for it? Does self-organization only work when the right skills, trust, and shared values are already in place? Can control without competence cause chaos? We dig into what it really means for modern teams and why it’s still controversial today.
Topics covered in this episode include:
- Why is Agile Manifesto Principle #11 frequently misunderstood in organizations?
- What dangers arise when control is handed over without building XP competence first?
- How can mob programming and collective learning raise a team’s ability to self-organize effectively?
- What role do psychological safety, trust, and leadership support play in enabling autonomy?
- Why must Agile principles be applied together rather than in isolation?
- How does Principle #11 connect to Lean thinking and the reduction of common wastes in software development?
- What real-world lessons show how solid architectures can emerge naturally through collaboration?
- What practical advice can leaders and agile coaches use to balance empowerment with readiness?
The conversation highlights both the promise and the potential pitfalls of applying Agile Principle #11.
This episode is useful for anyone who works in software development, engineering leadership, product management, or Agile coaching and wants to understand how to create conditions where self-organizing teams thrive instead of flounder.
Video and Show Notes: https://youtu.be/lTPtr8t3yaM
This special episode of The Mob Mentality Show is a cross-post from Tuple’s podcast/videocast Distributed, where Chris and Austin join host Jack Hannah for an in-depth conversation about mob programming, agile leadership, and the evolving role of AI in software development.
Originally recorded for Distributed, this discussion brings a fresh outside perspective to topics Chris and Austin have explored in over 300 episodes of The Mob Mentality Show—but here, they dive even deeper into the origins of mob programming, how it spread across the organization, and what it takes to protect team culture while scaling.
Listeners will hear stories about early experiments—like rearranging office spaces to make pairing/mobbing possible—navigating challenging product owner relationships, and using “cellular division” to grow teams without losing their collaborative spirit. The conversation also covers AI in social coding, from generating code in domain-specific languages to treating AI as another member of the mob, plus honest thoughts on whether AI could ever replace pair or mob programming.
Key Topics in This Cross-Post Episode:
- How one team’s mob programming experiment became an org-wide practice
- Lessons from creating and sustaining 300+ agile/XP episodes
- Office and workflow changes that enable collaboration at scale
- Maintaining team culture through growth and change
- Where AI fits (and doesn’t) in mob and pair programming
- Practical advice for teams without internal XP mentors
- The future of AI in collaborative software development
If you’re interested in agile leadership, developer experience, extreme programming, or the human side of software engineering, you’ll get proven strategies you can apply immediately—plus inspiration from seeing how practices spread beyond their starting point.
Video and Show Notes: https://youtu.be/Cd0L4jyaUIg
What does it really look like when Agentic AI systems are integrated into some modern software teams? In this episode of the Mob Mentality Show, we sit down with David Hirschfeld—founder and CEO—to unpack real-world experiences with Agentic AI, prompt engineering, and workflow automation in dev environments.
This is not a theoretical discussion. David brings firsthand stories of building and deploying AI-powered agents. We explore the hands-on challenges and breakthroughs that come with treating AI like a junior developer, giving it structured workflows, and designing systems that can improve with feedback.
Highlights include:
- Is “prompt engineering” dead?
- What Agentic AI is doing right now to reduce busywork and boost flow and what are the current shortcomings
- How AI agents can integrate with tools like Jira and Slack
- The cultural shifts needed to make AI part of your agile team
- Pitfalls of over-reliance on AI and the importance of confidence thresholds (e.g., big bang AI slop vs. small batch AI with verified output)
- How voice and vision AI are expanding what’s possible in software development
- When to automate, when to augment, and when to stay manual
- The surprising power of “smart laziness” in engineering productivity
- Lessons from real teams automating their development processes
Whether you’re a dev, product manager, or just AI-curious, this episode offers a rare behind-the-scenes look at how agentic systems are being used today—not in the future—to transform engineering work.
Video and Show Notes: https://youtu.be/cMhnIeGu3Js
How do you scale an agile team without sacrificing collaboration, flow, or developer experience?
In this episode of the Mob Mentality Show, we’re joined by Brice Ruth—engineering leader at Flexion and ensemble programming advocate—for a deep dive into what it takes to build high-functioning, adaptable software teams through a concept he calls “mob meiosis.”
We explore Brice’s journey from solo coding to full-time mob programming, and how his experience in the industry and in government contracts shaped his philosophy on team dynamics, learning cultures, and system design. If you’re looking for actionable insights into building fast feedback loops, enhancing developer onboarding, or evolving your mob into multiple autonomous mobs, this is the episode you don’t want to miss.
🔍 What you’ll learn:
- What “mob meiosis” is and how it enables team scaling without silos
- How to engineer feedback loops that operate across code, communication, and team structure
- Why ensemble programming improves developer flow, learning, and job satisfaction
- Lessons from transitioning into mobbing full-time—and how to make it sustainable
- Tips for fostering a culture where pairing, mobbing, and continuous improvement thrive
Whether you’re an agile coach, engineering manager, or developer looking to elevate your team’s practices, Brice brings a sharp, experience-backed perspective on what it means to lead with feedback, prioritize team health, and scale with purpose.
🎙️ Subscribe to the Mob Mentality Show for more episodes on ensemble programming, agile culture, and modern software team dynamics.
Video and Show Notes: https://youtu.be/W0eJFMzbBME
In this eye-opening episode of the Mob Mentality Show, we sit down with software engineer and consultant William Bernting to explore a radical approach to hiring, teamwork, and technical leadership.
William walks us through his real-world experience with mob programming interviews—a collaborative hiring process where candidates join the team in an ensemble coding session, not a contrived solo coder test. He shares the surprising benefits of evaluating candidates through communication, alignment, and problem-solving over individual technical trivia.
We dive into:
- Why mob programming is a great way to assess team fit and long-term success
- How to structure collaborative interviews that reduce anxiety and reveal true strengths
- What happens when you ditch traditional project-led methods and focus on predictability through steady flow
- How the Cynefin framework helps make sense of complex team dynamics and guides leadership decisions
- What freelance engineering looks like when trust, autonomy, and collaboration lead the way
William also discusses how he's made his work more stable and sustainable—for both clients and team members—without relying on estimates or rigid plans. Instead, he uses continuous delivery, test-driven development (TDD), and mobbing to achieve results that are both reliable and adaptable.
Whether you're a hiring manager rethinking your interview process, an engineer looking to join better teams, or a leader trying to move beyond chaotic delivery cycles, this conversation offers practical takeaways and fresh perspective.
🧠 Topics covered:
- Mob Programming Interviews
- Collaborative Hiring
- Cynefin Framework in Tech
- Predictability Without Projects
- Freelancing in Software Engineering
- Team Fit Over Resume Skills
- Agile Leadership Without Estimates
Video and Show Notes: https://youtu.be/nnR3_V8FrMQ
In this episode of the Mob Mentality Show, we sit down with Taimoor Imtiaz—CTO at a fast-moving, bootstrapped startup—for a raw, insightful dive into how his small dev team applied mob programming, trunk-based development, and GitHub Flow to accelerate delivery without sacrificing code quality.
Taimoor shares the journey of how his team transitioned from traditional PR-based workflows to real-time collaboration in mobs. Along the way, they faced timer-switching friction, monorepo challenges, and the trade-offs of scaling extreme programming practices in a production environment.
If you’ve ever wondered how mob programming plays out in a high-pressure startup setting—or whether trunk-based development is viable outside of big enterprise environments—this conversation is for you.
What you’ll learn in this episode:
- How GitHub Flow can be adapted for trunk-based development
- Why mob programming improved debugging and reduced defects
- Where mob timebox timers went wrong—and what the team did about it
- The real impact of developer experience and culture on delivery speed
- Lessons learned from using a monorepo in a fast-growing codebase
- Using extreme programming when resources are tight
Whether you’re a startup CTO, team lead, or individual contributor looking to evolve your team’s workflow, this episode offers real-world insights into modern software development practices that actually work under pressure.
Video and Show Notes: https://youtu.be/yTbzycv9qw4
📚 How does Mob Programming really work in the college classroom? In this episode of the Mob Mentality Show, we reconnect with Professor Ben Kovitz to explore the raw lessons, surprising wins, and tough challenges from a full semester of mob programming in a college software design course.
Ben shares what happened when he replaced traditional lectures with real-world collaboration. The results? Students developed practical coding skills, improved their communication, and learned to work together as a true software team—less ego, more shared ownership. From early wins with small group design exercises to complex struggles with C++ memory management and GUI libraries, Ben walks us through what worked, what bombed, and what he’d change next time.
We break down:
- Why mob programming created stronger learning and better teamwork than expected
- How structured rotations got everyone participating and avoiding common pairing pitfalls
- The highs and lows of using C++ and Qt in a classroom setting
- The unexpected power of students struggling through real software challenges together
- Lessons on undo implementation, design patterns, and memory management from hands-on mobbing
- How a semester wasn’t enough time to fully teach long-term code stewardship and habitable design
- What might scale—or fall apart—if mob programming were applied to larger classes
- How this classroom experience mirrors the real world: legacy code, fast feedback, technical debt, and learning as you go
Whether you’re a software engineer, an educator, or someone passionate about team learning, this episode gives you actionable insights into mob programming as both a teaching tool and a real-world development practice.
We also explore questions like:
- Can mob programming work with 30+ students?
- How can solo work and group collaboration coexist in the best learning environments?
- What does it take to create code that’s not just correct—but actually pleasant to maintain?
If you’re interested in agile learning, collaborative coding, and pushing the boundaries of how we teach and work as software teams, this episode is for you.
Video and Show Notes: https://youtu.be/kbNEfAcfmeo
🎲 In this episode of the Mob Mentality Show, we dive into a unique and game-changing (literally) approach to learning Test-Driven Development (TDD) with Ted M. Young (JitterTed), John Wilson, and Janis Kampe.
Discover the origin story of the TDD board game that started as a simple teaching aid and evolved into a powerful learning experience for developers, teams, and even product managers. Hear how this game went from casual pub nights to becoming a staple for some in team training sessions, meetups, and Agile coaching toolkits.
We break down:
- ✅ How the TDD board game helps teams internalize the deeper steps of TDD beyond the basic "Red-Green-Refactor" mantra.
- ✅ Why the game’s focus on prediction, risk management, and working in small steps transforms the way people think about writing code.
- ✅ The surprising ways the game builds psychological safety, making it accessible even to people new to TDD or nervous about exposing gaps in their knowledge.
- ✅ How the game naturally leads to ensemble (mob) programming and seamless transitions into hands-on coding platforms like CyberDojo.
- ✅ Practical tips on using the game to onboard, coach, and improve team collaboration—whether you're remote, hybrid, or in-person.
We also explore the importance of failing safely, incremental learning, and how the game allows players to experience both the thrill of success and the consequences of cutting corners—without the high stakes of real-world code.
Whether you're a developer, Agile coach, product manager, or just curious about TDD, this episode will give you actionable insights on:
- 🛠 How to enable continuous learning in your teams.
- 🎯 Why predicting outcomes matters more than just getting green tests.
- 🎮 How gamification makes TDD fun, social, and sticky.
Key Topics:
- TDD Board Game Mechanics & Variations
- Psychological Safety in Learning
- Risk vs. Reward in Software Development
- Ensemble Programming (Mob Programming)
- Transitioning from Game to CyberDojo
- Practical Coaching Tools for TDD and XP
- Building Stronger Developer-Product Manager Collaboration
Video and Show Notes: https://youtu.be/GjcUdoS5K6I
👨💻 Legacy code isn’t just old untested code—it’s a symptom of deeper problems in your organization. In this no-fluff episode of the Mob Mentality Show, we’re joined by Agile and technical coach Wouter Lagerweij to break down why legacy issues persist and how shared responsibility between product and engineering is the key to meaningful change.
🎯 What we cover in this episode:
- Why legacy systems are just as much about organizational baggage as they are about outdated code
- How true Agile teaming—swarming, pairing, mobbing—can unlock speed, learning, and fun
- Why your bug tracker is a graveyard, and how a zero bug policy can reset your team’s quality bar
This is a grounded, experience-rich conversation packed with practical insights for developers, team leads, product managers, and anyone serious about improving delivery without adding more process theater.
✅ You’ll come away with:
A broader definition of legacy and how to confront it
Concrete examples of effective team collaboration models
A new perspective on software quality and defect tracking
Proven ways to foster stronger cross-functional ownership
👤 About the guest:
Wouter Lagerweij is an independent Agile Coach based in The Netherlands and operating throughout Europe. He loves spending time with teams and organizations to figure out how to improve the way they make software, and make it more fun. To make that happen he uses the knowledge and skills gathered in over eighteen years of experience applying Agile processes and practices from XP, Scrum, Kanban, Continuous Delivery, DevOps, Lean and Systems Thinking. To turn those improvements into real business opportunities, he has added Lean Startup/Lean Enterprise approaches. Occasionally, he even uses common sense. 😅
Video and Show Notes: https://youtu.be/me9CSgmIRk8
🎙️ What happens when software engineers and leaders don’t speak the same language? How do context-free Agile practices and technical dogma lead teams astray? And how do we create engineering cultures that deliver real business value without burning out?
In this Mob Mentality Show episode, we sit down with Kyle Rowland—leadership and software consultant, 20-year software engineering veteran, and author of Powerful Profitable Software Products: The Executive Guidebook—to tackle the tough questions at the heart of sustainable, impactful software delivery.
💡 What We Cover in This Episode:
🔧 The Engineering-Leadership Impedance Mismatch
Why do engineering leaders and business leaders often talk past each other? Kyle shares how focusing on both “how” we build and “what” we build—can prevent burnout, bottlenecks, and bad outcomes. We explore why real innovation depends on creating win-win systems, not siloed thinking.
⚠️ The Danger of Context-Free Agile
Many teams argue about Agile, TDD, TBD, and pairing without understanding the systems that make those practices work. Kyle unpacks how context, principles, and shared goals determine whether these tools help or hurt—and how to avoid cargo cult Agile.
🔬 Empiricism vs. Philosophy in Tech Decisions
Is the Agile Manifesto's call for empiricism enough? Or is there still a place for a priori reasoning (argument from principle) in engineering? Kyle argues for a balanced approach—using experiments where we can, and wisdom where we must.
⏱️ The 1:40 Rule and Escaping Tactical Overload
Are you buried in endless 1-on-1s and tactical firefighting? Kyle introduces the “1:40 rule”—a lens for spotting when leaders are too involved in details and not investing in system-level growth. He explains how to avoid organizational entropy and shift your focus from maintenance to momentum.
📚 Plus: Behind the Book
We go deep on Kyle’s new book Powerful Profitable Software Products, exploring practical ways leaders can move from reactive chaos to purpose-driven product delivery—while empowering teams and aligning with business goals.
🎧 Whether you're an engineering leader, product owner, or software dev, this episode is packed with insights on leadership, systems thinking, quality, speed, and how to build software that matters.
FYI: Video and Show Notes: https://youtu.be/oCK1lMa2s9A
What if your beliefs—about work, people, or even yourself—are quietly holding you back? In this episode of The Mob Mentality Show, we sit down with visual thinker, author, and accidental Mob Programming anthropologist Dave Gray to unpack the power of belief, clarity, and collaboration in tech and beyond.
Dave Gray is known for Liminal Thinking—a book about understanding the invisible beliefs that shape behavior and systems. But did he know he was writing a book about us? Turns out, our Mob Programming origin story and Dave’s journey are more connected than you’d expect.
With roots as an artist, Dave brings a rare perspective to complex tech and business systems. From prior infographic posters that demystified RFID and Bluetooth when they first came out, to visual guides on inner transformation and his latest books, Dave's work simplifies the complicated and builds bridges for real understanding.
With Dave we explore:
- What led Dave from agile software development to Liminal Thinking
- Why most Agile transformations fail
- How to navigate confusing resistance—are people really lost, or just saying “no”?
- The principles behind creating safe spaces and disrupting unhelpful routines
- Visual and liminal thinking for fostering organic authentic change, not just communication tricks
- Raw observation vs. narrative: how perception can distort reality
- Why having lunch with someone you think is "crazy" or "stupid" might be the wisest move
- The psychology behind tech resistance, organizational inertia, and true agility
We also revisit how Woody Zuill and our original Mob Programming team with Chris Lucian smashed the belief that “real work” only happens in cubicles and outside of "meetings." The mob origin story had Liminal Thinking on full display as that team reflected, questioned, and ultimately acted in defiance of broken norms. The result? A shift in how we define space, collaboration, and innovation as Dave captures in his book.
If you work in tech, lead change, facilitate teams, or just feel stuck inside outdated ways of working, this episode is for you.
Video and Show Notes: https://youtu.be/fWF6kQBRdhg
In this thought-provoking episode, we sit down with Tobias Mayer—author, coach, and longtime voice in the Agile world—to explore the journey from his early discovery of XP (Extreme Programming) in 1997 all the way to today’s debate around the death of Scrum.
Tobias shares his personal transformation from developer to Scrum Master, his resistance to early XP, and how he learned great practices from developers he managed. We unpack his reflections on Agile’s semantic drift, the role of Scrum Masters as change agents vs. bean counters, and what happens when teams do Agile without even knowing the Agile Manifesto.
🔍 Topics we dive deep into:
- Discovering XP through a paper against it 😅
- When “Scrum” became a buzzword and what was lost in translation
- What it really means to live the values of the Agile Manifesto
- XP coaches, grassroots change, and learning from your team
- The difference between top-down control and emergent discovery
- Misused metaphors in tech: “firefighting,” “war rooms,” “soldiers,” and more
- Are software teams more like engineers, artisans, or ensembles?
- Can DORA metrics (DevOps Research and Assessment) prove or disprove Agile’s effectiveness?
We also dig into mob programming (aka mobbing)—what it means, why the name matters, and whether or not new metaphors like “ensemble programming” or “teaming” (à la Amy Edmondson) better reflect how high-performing teams really work.
💡 Plus:
- The problem with the Product Owner (PO) role in Scrum
- Why language in IT shapes behavior—for better or worse
- Applying Artful Making to modern product development
- Rethinking business through the lens of theatre, philosophy, and cooperative economics
- The importance of psychological safety, dissent, and experimentation in creating real agility
Tobias brings rich context from classics, theology, and history—yes, even turning a conference t-shirt into fashion—to challenge how we think about building products, teams, and businesses.
🛠️ Whether you're into XP, Scrum, Mob Programming, Lean, or simply want to rethink your metaphors and language at work, this episode delivers grounded insight, sharp critique, and fresh perspectives.
👉 Subscribe for more conversations at the intersection of agile thinking, real teamwork, and modern product development.
Video and show notes: https://youtu.be/ZFoY-De91BE
🎙️ In this episode of The Mob Mentality Show, we’re joined by Professor Ben Kovitz—a former software developer with 15 years of industry experience who went on to earn a PhD and is now teaching Computer Science at Cal Poly Humboldt. Prof Ben flips the script and brings his own real-world mob programming questions—challenges he’s faced while mobbing live with college students in the classroom.
This is not theory. These are hard-won questions from the trenches of mob programming in a learning environment, where curiosity meets complexity, and group dynamics get real.
🔍 We dive deep into 5 key challenges:
-
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. -
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. -
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. -
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. -
Mobbing with Documentation and AI:
Should the mob read documentation together? What about using AI tools? We cover how teams can mob to teach effective doc reading, search strategies, and prompt engineering, while still adapting workflows to individual learning zones and WIP (Work in Progress) constraints.
💡 This episode is full of insights on:
- Group facilitation in real-time coding
- Balancing solo and group learning
- Creating psychological safety in a mob
- Adapting mob rules to context—not dogma
- Bringing agile, XP (Extreme Programming), and education together in the mobbing practice
Video and Show Notes: https://youtu.be/nAAI5f7-vTs
🏈 Welcome to another episode of the Mob Mentality Show, where we explore the intersection of software development, leadership, and real-world lessons—from the unexpected to the game-changing. This time, we're talking Coaching Credits—as seen in the addictive mobile football game Retro Bowl—and how they map directly to trust, influence, and leadership in software teams.
🎙️ What are Coaching Credits?
In Retro Bowl, Coaching Credits represent the respect and trust you’ve earned from players, staff, and fans. They let you upgrade your team, hire top-tier talent, and level up your environment. In software development, we argue Coaching Credits are just as real—earned through Extreme Programming (XP), Mob Programming, Test-Driven Development (TDD), Continuous Delivery (CD), and strong relationship-building.
👶 Austin kicks it off with a story about trying to stay awake helping his wife with their new baby—turning to Retro Bowl as a late-night lifeline. That sparks a deep dive into what the game teaches us about:
- Building trust and respect through small wins
- The balance between performance and relationships
- Using “credits” (influence) wisely inside and outside your team
- How to upgrade your environment and talent pool over time
- What happens when you try to “spend” influence you don’t actually have
👨💻 In Dev Culture Terms:
Earn trust by delivering value. Spend it by coaching others, refactoring code, upgrading environments, or influencing org-wide decisions. Just like in Retro Bowl, you can overreach. Think: trying a big move when your trust bank is empty = a bounced check.
📘 We also tie Coaching Credits to Stephen Covey’s 7 Habits—specifically, the idea of an emotional bank account—and reflect on how these lessons align with the origin story of mob programming.
🚨 Key Questions We Explore:
- Can you go into Coaching Credit “debt”?
- Is quick wins and trust the only way forward when you're starting from zero?
- Are you too transactional in how you lead or code?
- Should someone build a Software Dev Sim game like Retro Bowl? 😅
💡 If you're a software engineer, tech lead, or engineering manager, this episode offers a fun but surprisingly deep framework for thinking about how trust, respect, and influence shape the way you build products and teams.
Video and Show Notes: https://youtu.be/ZWgOkphBFNI
🎙️ Ever faced a product vision so massive it felt impossible to start? In this Mob Mentality Show episode, we tackle the art and science of Story Splitting — breaking down huge dreams into small, deliverable slices without losing momentum or clarity.
We explore real-world strategies, including:
- Asking the hard questions like Do we really need to release everything at once?
- Using SPIDR (Spike, Path, Interface, Data, Rules) to guide story splitting
- Implementing Feature Flags (tools to enable/disable features without deploying new code) for flexible delivery
- Creating color-coded diagrams to visualize release order and dependencies
- Practicing "Yes, and" techniques to manage big customer asks without abandoning Agile values
- Running post-mortem retrospectives focused on improving splitting practices
- Mapping ideas with Discovery Trees (visual structures for feature evolution)
- Handling the tension between Big Bang marketing launches and incremental delivery
- Influencing sales and marketing teams to only sell what's already done vs. selling the future
- Identifying the impact of poor story splitting on technical debt and customer trust
- Differentiating splitting technical work vs. splitting user-facing features
- Teaching business stakeholders the fundamentals of CD (Continuous Delivery) and good story practices implicitly vs. explicitly
- Working through known unknowns vs. unknown unknowns in product discovery
- Using the Cynefin Framework (a model for navigating complexity) to decide splitting approaches
- Prioritizing with cost of delay and story split diagrams to maximize value
This episode is packed with hands-on advice for developers, product managers, Agile coaches, and leaders looking to move fast without breaking things. Whether you're struggling with overwhelming customer requests, complicated roadmaps, or internal misalignment, learning how to split the impossible is key to success in Agile, Continuous Delivery, and Lean Product Development.
Video and Show Notes: https://youtu.be/MjwIkiM25xM
🎙️ What’s really happening inside your engineering org?
In this episode of the Mob Mentality Show, we sit down with Philip Borlin, Director of Engineering and advocate for lean thinking, mobbing, and team capability building, to uncover how Gemba Walks, smaller batch sizes, and healthy team nudges reveal the actual state of your tech organization—not just what reports say.
We explore how leaders can stop flying blind and start leading based on facts from the field.
🔍 Topics Covered:✅ Gemba Walks (Japanese term meaning “go to the real place”):
- Why your assumptions about how work gets done are probably wrong
- How spending even one hour a week in the mob or at the code level changes everything
- The myth of managing solely through middle managers
- Why high-fidelity information beats filtered reporting
- Remote-friendly adaptations: mobbing, Lean coffees, and async insight gathering
✅ Mobbing (also known as ensemble programming):
- How mobbing surfaces capability gaps and builds shared understanding
- Growing capabilities without enforcing rigid standards
- Real stories of capability fire drills, single points of failure, and org fragility
- “Low and slow” growth as the only sustainable path to true skill development?
✅ Fixing Batch Size and WIP (Work In Progress):
- How large batches lead to delivery waste, delays, and bugs
- The surprising power of reducing ticket size to unlock flow
- Socratic coaching at stand-ups to improve team work slicing
- Giving permission to drop non-priority work and focus only on what matters
✅ Building a Learning Culture:
- Why capability resilience > retaining every team member forever
- Using “nudges” and peer pressure the right way
- Investing in bright spots without ignoring skeptics
- Cultivating environments where psychological safety and growth feed off each other
💡 Whether you’re a Director of Engineering, Tech Lead, Agile Coach, or Software Engineer, this episode gives you practical ways to lead with clarity, scale team capability, and build resilience into your org’s DNA.
🎧 Subscribe now so you don’t miss the drop:
👉 https://www.mobmentalityshow.com/
Video and Show Notes: https://youtu.be/bFMD0AsVDUA
What if your team didn’t need branches at all? 💥 In this episode of The Mob Mentality Show, we sit down with Ron Cohen, CTO and co-founder of Bucket, to unpack the real story behind Trunk Based Development (TBD) and the practical use of Feature Flags.
Ron stirred the pot online by challenging common assumptions around TBD — and now he’s here to clear the air.
We talk about:
- What Trunk Based Development really means (Hint: It’s not just “no branches”)
- Why TBD isn’t just a Git strategy, but a safety mindset often backed by solid practices like Pair Programming, Mob Programming, and TDD (Test-Driven Development)
- Gitflow vs. TBD — which one sets your team up to move faster and safer?
- The myth that TBD = chaos, and why short-lived branches might still play a role
- How mobbing and pairing can make TBD not just possible, but powerful
We also dive deep into Feature Flags (a.k.a. Feature Toggles):
- Why Ron became obsessed with them — and how they changed how his teams ship code
- How to use toggles for faster releases, safer experiments, and smoother collaboration between devs, Product Owners (POs), and marketing
- The difference between feature flags that require a deployment and those that don’t
- The value of “dogfooding” your features in production before a full rollout
- Why not all toggles are created equal — from simple UI switches to ops-level controls
- How to avoid the mess of long-lived toggles and clean up after experiments (Austin, we're looking at you 😅)
Plus:
- How flags can power A/B testing and internal beta programs
- Fowler’s definition of Feature Flags — and how it is in action
- Using toggles to build internal and external trust
- Ron’s framework for different kinds of flags in different contexts
Whether you're deep into CI/CD (Continuous Integration/Continuous Delivery), trying to tame your branching strategy, or just want to ship smarter — this episode’s packed with insights you can use immediately.
🎧 Subscribe and listen on your favorite platform:
👉 https://www.mobmentalityshow.com/
Video and Show Notes: https://youtu.be/4PZN1yO8l2c
What happens when a college software design course ditches traditional lectures and embraces Mob Programming?
In this episode of the Mob Mentality Show, we sit down with Ben Kovitz, a former software developer turned professor at Cal Poly Humboldt, to explore his innovative approach to teaching software design through mobbing.
Topics Covered:✅ From Industry to Academia: Why Ben left software development to become a professor and how he discovered mob programming.
✅ Redefining Software Education: Instead of 30 traditional lectures on software design, Ben’s students learn by doing—designing software while coding.
✅ The Power of Mobbing in the Classroom: How students collaborate in the mob of 8, rapidly sharing knowledge and tackling challenges together.
✅ Fast Learning vs. Lectures: Why mobbing enables faster knowledge transfer compared to passive lectures.
✅ Strong-Style Navigation: How rotations and fast timers helped to stimulate a highly effective learning environment.
✅ The Role of the Navigator: How students help each other navigate, learn C++ and the QT framework, and document key lessons from each mob session.
✅ Real-World Software Challenges: Simulating legacy code maintenance, evolutionary design, and design patterns like MVC (Model-View-Controller).
✅ Overcoming Student Struggles: What happens when students don’t know how to navigate? How asking for help and learning together fosters growth.
✅ Teaching Through Experience: Letting students experiment with flawed solutions before introducing better design principles.
✅ Assessment & Engagement: How Ben measures student participation, engagement, and learning outcomes in a mobbing environment.
Why This Matters:Traditional software design education can leave students unprepared for the realities of refactoring real code and collaborative development. By integrating Mob Programming, refactoring techniques, and hands-on problem-solving, Ben Kovitz is equipping the next generation of developers with practical, real-world skills and deeper design insights.
📢 Subscribe to the Mob Mentality Show to stay updated on the latest insights in Mob Programming, Extreme Programming (XP), Agile, and collaborative software development!
🎧 Listen on your favorite podcast platform: https://www.mobmentalityshow.com
🔔 Don’t forget to LIKE, COMMENT, and SUBSCRIBE for more episodes on software development, coding education, and team collaboration!
Video and Show Notes: https://youtu.be/Rajvp2nrg1A
🔥 How do you actually build great software developers? How do you debug like a pro? And what happens when XP (Extreme Programming) makes a comeback after the Scrum backlash?
Join us as Garrick West—a seasoned XP practitioner, Agile coach, and software craftsmanship advocate—dives into:
✅ Building Agile Software Developers: From XP mentorship to industry-academia collaboration
✅ The Best Debugging Strategies: Unpacking The Debugging Book and applying its rules in a mob
✅ Reviving XP & Software Crafting: Why XP is more crucial than ever in Agile teams
🚀 Garrick's Story: From Early Coding to XP Champion
Garrick started coding at 10 years old (at day camps in the 80s! 😅), earned a Computer Science degree, and had his development worldview shaped by reading the first edition of Extreme Programming Explained. He has worked at XP-centric organizations, trained teams in TDD (Test-Driven Development), Ensemble Programming, and CI/CD (Continuous Integration/Continuous Deployment), and even revamped a college curriculum from Waterfall to XP/Scrum.
🎯 "Building" Agile Software Developers
- The power of an XP coach early in a developer’s journey
- Public speaking as a dev skill? (Toastmasters, teaching at community college)
- What happened when Garrick helped convert a college curriculum from Waterfall to XP/Scrum?
- Industry experts + academia: How can professional devs and educators collaborate better?
- The apprentice model: What it means and why learning stages (like the Dreyfus Model) matter
- AI & developer education: Does AI replace early learning stages, or is it just a slick salesman?
- Scaling Gilded Rose Kata to different skill levels
- Test Coverage as a red herring—what should we focus on instead?
🐞 Debugging: The Missing Developer Superpower
Ever heard of The Debugging Book? Most developers haven’t—but it’s a game-changer. We explore:
- Debugging as problem-solving, not just "stepping through" in an IDE
- The 9 Debugging Rules: From reading the manual to never throwing away a good test tool
- How to gamify debugging in a mob & introduce a "debugging auditor" role
- The anti-pattern of multiple experiments at once—and how to avoid it
- Why debugging is like navigating a labyrinth with a million wrong paths
🔄 Reviving XP & Software Crafting After the Scrum Backlash
- XP fills Scrum’s missing middle: Building the right thing (Scrum) AND building it right (XP)
- How Scrum without XP leads to a “Ball of Mud” in just 18 months
- Why XP + Lean is the ultimate combination
- Breaking free from sprints & pressure cookers—just focus on continuous iterations
- Can XP stand without Scrum? Or does Scrum need XP?
💡 Don’t miss this high-energy, insight-packed conversation with Garrick West!
📢 Comment below: What’s YOUR experience with XP, Agile, or debugging challenges?
Video and Show Notes: https://youtu.be/vxLDm-13Ny4
🚀 How do Game Jams accelerate learning? Can mobbing make game development more effective? In this episode of the Mob Mentality Show, we dive deep into Game Jams, Mobbing, and Game Dev Collaboration with James Herr—a full-stack developer, game dev enthusiast, and published game creator on Steam.
🎮 What You'll Learn in This Episode:🔹 What Are Game Jams and why they’re a must-try for devs?
🔹 The tech stacks and tools commonly used in Game Jams
🔹 How themes shape a Game Jam’s creativity and constraints
🔹 How James is bringing mobbing into Game Jams
🔹 The difference between solo development, swarming, and full mobbing?
🔹 Pros & Cons of Mobbing Game Jams—Does it boost creativity or slow things down?
🔹 How Discord & Twitch fuel real-time game dev collaboration
🔹 Can Twitch chat act as a “navigator” in game development? Does the live audience guide decisions?
🔹 How Game Jams reveal code smells faster and teach refactoring & design patterns
🔹 Why public game dev can be a game-changer for learning speed
🔹 How Game Jams can simulate real-world software challenges and improve teamwork
🔹 Mob timer tools & Git handover techniques for smoother collaboration
🤝 Why This Episode Matters:Mobbing isn’t just for software teams—it’s transforming game development, learning, and onboarding. James shares his firsthand experience mobbing with kids, running Game Jams with cross-discipline teams, and teaching mobbing roles in game dev. Whether you’re a seasoned developer, indie game creator, or just curious about Game Jams, this episode is packed with actionable insights!
📢 Want to Join the Game Dev Community?
James discusses how Discord and Twitch connect developers worldwide, making it easy to collaborate, get feedback, and learn from others. Checkout James' communities here: https://jamcraft.io/
🎧 Subscribe & Listen Now!
Don’t miss out! Subscribe to the Mob Mentality Show and get notified when this episode drops:
🔗 https://www.mobmentalityshow.com/
Video and Show Notes: https://youtu.be/AZEH_FmBBKs
🚀 Why is there so much confusion around Test-Driven Development (TDD) and Automated Testing? Why do many developers struggle with testing, and what are they getting wrong? In this episode of the Mob Mentality Show, we sit down with Jason Swett—author, speaker, and a go-to expert on Rails testing—to unpack the most common misconceptions, challenges, and best practices in modern software testing.
🔍 Topics We Cover:
✅ Why Jason Swett is passionate about Automated Testing and why he wants to help the development community
✅ Misconceptions about TDD (Test-Driven Development)—not liking TDD itself vs. not liking something called "TDD"
✅ The reality of software testing—why most developers aren't doing it well and how to improve
✅ Testing vs. verification vs. specification—what is a test really? What is code?
✅ Red, Green, Refactor vs. Specify, Encode, Fulfill—what do these different ways of thinking about TDD highlight?
✅ Why software changeability matters and how to reduce the cost of ownership
✅ What are you actually testing? The difference between testing the product (e.g., squirt gun) vs. testing the system that builds it
✅ The role of automation in development—is code like factory machinery?
✅ How testing connects to broader software and team dynamics—beyond just writing tests
✅ Common pitfalls in testing and how to ensure your tests actually add value
✅ Logical debates vs. ego-driven arguments—how to have productive discussions about TDD
💡 Key Takeaways:
🔹 TDD is often misunderstood—before rejecting it, understand what it really is
🔹 Many developers struggle with writing the right kind of tests—knowing what to test is critical
🔹 Automated tests don’t just verify code; they help manage change and reduce long-term costs
🔹 Good testing and TDD are about more than just code—they’re about communication, clarity, and better software development
📌 Who should watch/listen?
If you’re a developer, tester, software engineer, or tech lead who wants to improve your testing skills, understand TDD better, and learn from a Rails testing expert, this episode is for you!
🎧 Subscribe & Listen: Don’t miss an episode! Subscribe to the Mob Mentality Show on your favorite platform:
👉 https://www.mobmentalityshow.com/
🔥 Join the Conversation! Have thoughts on TDD and Automated Testing? Share them in the comments!
Video and Show Notes: https://youtu.be/_kL_tXiNcl4
How often should Agile teams reflect and adjust? Is your team on a road with switchbacks but they are not turning the wheel? In this episode of The Mob Mentality Show, we take a deep dive into Agile Principle #12, which states:
"At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly."
From a Mob Programming perspective, we explore what "tuning and adjusting" really looks like in high-uncertainty, high-interdependence work. Is it like steering a car, constantly making small adjustments, or is it something that requires far less steering? How do different approaches—Waterfall, 2 Week Scrum, and Mob Programming—each handle batch size and feedback loops with continuous improvement?
In This Episode, We Discuss:✅ Agile Principle #12—How it drives continuous improvement in teams
✅ "Regular Intervals"—Comparing Waterfall, 2-week Scrum sprints, and healthy mobbing
✅ Batch Size & Effectiveness—How small adjustments impact team agility
✅ Single vs. Double Loop Learning—Which leads to deeper team growth?
✅ Diversity & Focus—Does learning together accelerate improvement more than learning separately?
✅ The Cynefin Model—Navigating uncertainty and complexity in Agile work
✅ Liminal Thinking—How belief structures and assumptions impact team reflection
Many teams go through the motions of retrospectives, but are they truly adjusting their behavior effectively?
Join us for this insightful discussion where we challenge assumptions, explore deeper learning, and uncover the best ways to reflect, adapt, and improve as a team.
🎧 Subscribe & Listen:
Don't miss this episode! Subscribe on your favorite platform here:
🔗 https://www.mobmentalityshow.com/
📩 Connect with Us
Let us know your thoughts in the comments! How does your team reflect and adjust?
Video and Show Notes: https://youtu.be/ikmWgj44g28
How do you balance small, iterative progress with the vast unknowns of research and development (R&D)? Can test-driven development (TDD) literally or "in spirit" still provide value when you're navigating uncharted territory? In this episode of the Mob Mentality Show, we dive deep into the intersection of R&D Mobbing and software development, exploring real-world scenarios, strategies, and challenges teams face when innovating under uncertainty.
What You’ll Learn in This Episode:🔬 Chris's Journey with Mob Randori & R&D: From "we don’t know what we’re doing" to "we know what we’re doing"—how mob programming helped transform uncertainty into effective delivery.
🛠️ R&D vs. CD? Can teams practice continuous delivery (CD) even when tackling complex, unknown problem spaces? If so, is there a change in what is "delivered"?
📌 Keeping Small Steps & Feedback Loops in R&D: TDD is known for its rapid feedback and endorphin kicks—but how do you retain those benefits when exploring an unfamiliar landscape?
🔄 Adjusting Your Mobbing for the Task at Hand: When should you modify your mob programming approach to fit the nature of research-driven work versus production-level development?
🧗♂️ Clean Code Spelunking & Navigating the Unknown: Techniques for digging deep into existing codebases while ensuring safety and maintaining forward momentum.
🚩 Feature Flags & Safety in R&D: How to experiment with new ideas and do Trunk Based Development (TBD) without introducing instability to production.
📊 Transparency, Visualization & Business Buy-in: Addressing stakeholder fear of an "infinite problem space."
🧠 The Inverse of ZOMBIES in R&D Mode: How do you maintain focus, momentum, and value delivery when dealing with high levels of uncertainty?
⚡ Real-Life R&D Success Stories & Lessons Learned: Practical examples of mob programming driving R&D innovation in high-unknown environments.
If you’ve ever wondered how to keep experimentation structured, learning fast, and delivery continuous—even when dealing with complex unknowns—this episode is for you!
📌 Watch More Episodes & Subscribe on Your Favorite Platform: https://www.mobmentalityshow.com/
🔔 Don’t miss future episodes—hit the subscribe button!
Video and Show Notes: https://youtu.be/nipbhFopqMM
Is the ultimate Domain-Driven Design (DDD) dream having a domain expert fully embedded in a Mob? Or does it come with hidden trade-offs? In this thought-provoking episode of the Mob Mentality Show, we explore the benefits, challenges, and real-world experiences of having a domain expert (or product owner) participate full-time in a Mob—not just as a consultant but as an active driver and navigator.
🔹 What We Discuss in This Episode:
✅ Quick Access vs. Full-Time Participation – Is it better to have a domain expert available when needed or fully immersed in the Mob?
✅ Real-World Stories – Chris shares insights from four product owners with different availability levels and how that impacted effectiveness. Austin reveals what happened when a domain expert became a full-time Mobber.
✅ The Pros of a Full-Time Domain Expert in a Mob – Faster decisions, deeper collaboration, improved knowledge transfer, and more!
✅ Natural Synergy with DDD – How DDD experts seamlessly jump into code naming, improving model alignment.
✅ Testers & Domain Experts: A Similar Integration? – The parallels between merging testers into a Mob and embedding domain experts.
✅ Potential Downsides – Does being in the Mob full-time reduce a domain expert’s ability to stay ahead in their field?
✅ Autonomy & Learning Diversity – How does this setup impact team growth and decision-making?
✅ Is This the DDD Dream? – With fewer moving parts (like event storming), does a domain expert in the Mob make DDD even more effective?
✅ The Power of Different Perspectives – Why having a built-in devil’s advocate can enhance team decision-making.
✅ The Truth About Cryptic Code – Can a domain expert help clarify unclear code in real time?
🎧 Don’t Miss This Insightful Discussion!
Hit Subscribe and turn on notifications so you don’t miss future episodes! Find us on your favorite platform here 👉 https://www.mobmentalityshow.com/
What do you think? Would you want a domain expert full-time in your Mob? Drop a comment below! ⬇️
Video and Show Notes: https://youtu.be/7__ghFw_Z3g
Can a combo of Large Language Models (LLMs) and Domain-Specific Languages (DSLs) streamline development by automating repetitive patterns across teams? In this Mob Mentality Show episode, we dive deep into the intersection of AI-driven automation, code generation, and lean software development.
Join us as we explore:
✅ The "Generator for the Generator" Concept – How AI-powered tools and Mob Programming can create DSLs that automate code generation at scale.
✅ Handling Cross-Domain Development with DSLs – How DSL arguments can be leveraged to generate applications across multiple domains while maintaining usability.
✅ Serverless Infrastructure as Code (IaC) & Auto-Generated Apps – How to use DSLs to automate cloud deployment with Angular or Streamlit apps.
✅ The Challenge of UI/UX in Generated Code – When UI is too generic, does it hurt usability? Can a DSL strike the right balance between automation and user experience?
✅ Regeneration vs. Continuous Development – Should teams work exclusively in the DSL, or also refine the code it generates? How to handle sync issues when regenerating applications.
✅ Turning Docs into Code with a DSL Converter – Automating workflows by transforming team documentation into executable code.
✅ Mob Automationist Role Inception – Is the next evolution of Mob Programming automating the automation?
✅ ZOMBIE Test Generation & Nested Python Dictionaries – How automated testing fits into the DSL-driven workflow and whether a DSL can be as simple as a structured Python dictionary.
🎯 Whether you’re a software engineer, an agile practitioner, or just fascinated by AI-driven development, this episode is packed with real-world insights into DSLs, LLMs, and the future of lean automation.
🔔 Don't miss out! Subscribe to the Mob Mentality Show on your favorite platform:
👉 https://www.mobmentalityshow.com/
Video and Show Notes: https://youtu.be/0q3jaX6_bfw
Explore the exciting intersection of human collaboration and artificial intelligence (AI) in software development with this insightful episode of the Mob Mentality Show. Recorded for the 2024 UACon Winter: The Future of Product Development Summit on December 10, 2024, Aaron Griffith and Parker Barrett joins Austin to dive deep into how Mob Programming and AI are reshaping the way we build and test software.
This episode is packed with practical insights, real-world examples, and actionable strategies for leveraging AI with a mob programming style. Whether you’re an AI enthusiast, a software developer, or just curious about the future of collaboration, this session has something for you.
What You'll Learn in This Episode:
🔹 What is Mob Programming?
🔹 The Origin Story of Mobbing with AI – Discover how our human teams began mobbing with AI tools like ChatGPT and GitHub Copilot to enhance software development processes.
🔹 AI-Driven Test Development in a Mob – See how AI can streamline test-driven development (TDD) workflows, making testing faster and more effective.
🔹 Testing with AI to Find ZOMBIES Test Cases (Zero, One, Many, Boundaries, Interface, Exceptional, Simplicity) – Learn how AI tools help identify missing test scenarios and code improvements.
🔹 AI Limitations and Warnings – Understand the ethical, technical, and operational challenges when incorporating AI into your workflows.
🔹 AI Mobbing Demo Highlights:
- AI-generated Flutter app complete with unit tests.
- AI-driven identification of ZOMBIES.
- Automated Continuous Integration/Continuous Deployment (CI/CD) pipelines powered by AI.
Why This Episode Matters:
As AI tools continue to evolve, understanding how they integrate with collaborative programming methods like Mob Programming and Extreme Programming (XP) is critical for staying innovative in the fast-paced world of software development. In this session, we not only discuss the benefits of AI but also provide a realistic view of its limitations and how to navigate them.
Perfect For:
- Developers and teams exploring AI-powered tools.
- Agile practitioners and extreme programming enthusiasts.
- Anyone curious about the future of software development collaboration.
Let’s shape the future of collaboration and development together!
Video and Show Notes: https://youtu.be/BsFPbYX4WXQ
In this thought-provoking episode of the Mob Mentality Show, we dive into the world of extreme ownership within a multi-mobbing environment. What happens when a mob/team wants to make a decision, like extracting a method, refactoring to a new pattern, or reorganizing code boundaries? Should that decision wait for approval from outside teams? Or does extreme ownership mean trusting the mob to act autonomously for maximum flow efficiency?
Topics Discussed:* Autonomy vs. Consensus: Should mobs prioritize quick decision-making or seek input from external teams? * Multi-Mob Context: Exploring the dynamics of multiple mobs interacting and how to handle shared ownership of repositories and projects. * Inverse Conway Maneuver: Can designing your organization’s team structures to match the architecture you want your systems to have prevent this problem? * Lean Thinking and Efficiency: How waiting for approvals from external owners can create lean wastes. * Boundary Flexibility: Should code and team boundaries be rigid or adaptable to changing circumstances? * The Monolith vs. Microservices Debate: Is the real issue a technical architecture debate or is the root problem found elsewhere?
Scenarios and Examples:* A hypothetical comparison of shared ownership in MS Word vs. MS Excel. * The impact of Joe Justice’s Law on decision-making and team interactions. * The challenge of managing too many communication nodes in multi-team environments.
Key Questions Discussed:* Is it more valuable to reduce the number of teams interacting with a repo? * Should boundaries of ownership evolve with time? * How can we balance flow efficiency with healthy collaboration across teams? * How does "Nothing in Tech Matters Except XP" impact this discussion?
Subscribe and Stay Connected:Don’t miss this insightful episode as we unravel these questions and more! Discover how the principles of extreme ownership and mob programming can transform team dynamics and decision-making processes in software development.
📢 Subscribe to the Mob Mentality Show on your favorite platform: https://www.mobmentalityshow.com.
🔔 Like, comment, and share to join the discussion and stay updated on upcoming episodes!
Video and Show Notes: https://youtu.be/rAT-EurLnrI
In this episode of the Mob Mentality Show, we dive into Sustainable Pace, a core principle of the Agile Manifesto ("Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely"). From software development to youth sports, we explore the massively destructive effects of an unsustainable pace and highlight the transformative benefits of a culture grounded in sustainable practices.
🔥 Key Topics Covered1. The Massively Destructive Results of Unsustainable Pace
- How the relentless work rate leads to burnout, dropouts, injuries, and errors.
- Insights from academic and medical studies showing the devastating effects of unsustainable workloads.
- Real-world connections to coding bug rates, over-specialization, and emotional exhaustion.
- Tim Urban's TED Talk ("Inside the Mind of a Master Procrastinator") and its ties to the procrastination monkey, panic monster, and unsustainable pace.
- Why misalignment between expectations and reality (e.g., unrealistic deadlines) breeds toxicity.
-
Radical Candor's "obnoxious aggression" and it can join forces with unsustainable pace to form a diabolical duo.
-
The Positive Results of a Sustainable Pace
-
Building high-quality, continuous delivery without chaos or burnout.
- The connection between psychological safety, inclusivity, and long-term success in both teams and individuals.
- Benefits of diverse experiences, low stress, and personal peace from a sustainable pace.
- Practical strategies to avoid contributing to toxic work or play environments.
-
Stories from youth sports coaching and tech leadership that illustrate how sustainable pace leads to lasting excellence.
-
Actionable Insights for a Better Future
-
How to shift from a culture of "run fast, burn out" to one of balance, productivity, and joy.
- The systemic changes needed to foster sustainable pace in tech teams and youth sports organizations.
- Why adopting sustainable practices isn't just about survival—it's about thriving.
🎙️ Why Listen?Whether you're a tech leader, Agile practitioner, parent, or coach, this episode is packed with actionable advice and thought-provoking discussions. Learn how sustainable pace can unlock continuous learning, higher quality results, and a more fulfilling life.
✅ Subscribe to Stay UpdatedDon't miss other enlightening discussions! Subscribe to the Mob Mentality Show on your favorite podcast platform or YouTube channel: https://www.mobmentalityshow.com
📢 Join the ConversationWhat’s your experience with unsustainable pace? How have you built or experienced sustainable practices in your work, team, or community? Drop your thoughts in the comments below and let’s talk!
Video and Show Notes: https://youtu.be/bTvjoGosBnw
In this exciting episode of the Mob Mentality Show, we sit down with Martin Christensen, a product transformation coach, to explore the pivotal power of mobbing in product discovery.
What You'll Learn in This Episode:Mobbing Product Discovery* What is Product Discovery? Understand the fundamentals user value, business value, and technical feasibility. * Mob Style vs. Solo User Interviews: Learn how mobbing on user interviews enhances insights through diverse perspectives and how it contrasts with traditional solo interviews. * The Benefits of Diversity: Discover why the mantra “Mob Anything” unlocks innovation, faster UI/UX iterations, and fewer lines of code while maintaining focus on user experience.
Collaboration, Psychological Growth, and Transformation* Barriers to New Methods: Dive into the psychological and organizational obstacles that can hinder teams from adopting mobbing or trying new approaches. * Adult Development and Teaming: Martin shares insights on how stages of psychological development and life events can break down egocentrism and foster stronger collaboration. * The "No Pain, No Gain" Paradox: Can growth happen without trauma? Discover the nuanced relationship between challenges, growth, and maturity in collaborative environments. * Impact of Complexity on Happiness: Unpack how the complexity of problems and overall team happiness affect the ability to work effectively as a mob.
Why Watch This Episode?If you’re passionate about product development, user experience, or team collaboration, this episode is packed with actionable insights and relatable stories. From understanding the power of mobbing in product discovery to overcoming barriers to psychological maturity in teams, this conversation will leave you inspired to experiment and grow.
🎙️ Don’t miss out!
Subscribe to the Mob Mentality Show today to catch this episode and explore other topics at the intersection of innovation, collaboration, and personal growth.
👉 Watch here or on your favorite platform: https://www.mobmentalityshow.com/
Video and show notes: https://youtu.be/IPYXElnuBns
Have you ever wondered who else is adopting mob programming? Or perhaps you’re curious about the diversity of organizations that practice ensemble programming? In this Mob Mentality Show episode, we take a deep dive into the Companies That Mob/Ensemble Program Board, a powerful tool for tracking and sharing insights about organizations, coaches, and educators engaging in mobbing practices worldwide.
Join us as we explore the story behind this invaluable resource and its broader implications for the mob programming community.
What You’ll Learn in This Episode:* Why Track Mobbing? Discover why Chris Lucian started documenting companies and organizations that practice mob programming, beginning with a simple blog post. * From Blog to Trello: Learn how this tracking effort evolved from a personal blog to a comprehensive Trello Board, making it easier to manage and share. * Uses of the Board: Explore the board’s practical applications, including showcasing the diversity of mobbing practices across countries, industries, and contexts like IoT (Internet of Things), eCommerce, hardware, firmware, software, government, and private sectors. * Related Resources: Uncover the connections between this board and other similar initiatives, such as the Software Professional Resources Board and the "We Do TDD (Test-Driven Development)" website. * Anecdotal ROI: Hear how this board can serve as anecdotal evidence of the return on investment (ROI) for mob programming from a "just sharing" perspective ( https://justsharing.dev/ ), helping promote its adoption in the software development community. * New Categories: Find out about Austin’s updates, which include categories for coaches and professors who practice mobbing. * Call to Action: Get inspired to contribute by adding new companies, organizations, or individuals to the board to help grow the global mobbing network.
Why This Matters:The Companies That Mob/Ensemble Program Board isn’t just a list—it’s a living resource that reflects the growing diversity and diffusion of mobbing practices worldwide. It’s a tool for saving time, building community, and promoting the Just Sharing mindset. Whether you’re a seasoned practitioner or a newcomer to mobbing, this board helps you connect with others and find inspiration for your own mob programming journey.
Get Involved:
Want to see the board in action? Check it out here: Companies That Mob/Ensemble Program Board.
Subscribe for More Episodes:
Don’t miss out on future episodes of the Mob Mentality Show! Subscribe on your favorite platform today: Mob Mentality Show Website.
Tune in and discover who else is mobbing—and why it’s transforming the way we work and learn!
Video and Show Notes: https://youtu.be/yCB4n-0nxQk
Have you ever wondered why Extreme Programming (XP) isn’t commonly taught in schools? In this engaging episode of the Mob Mentality Show, we dive into this intriguing question brought to us by the mob programming community.
🎓 What We Cover:
1️⃣ A Junior Developer's Dilemma: If schools don’t teach XP, does it mean it’s not critical for your career?
2️⃣ Academia’s Pushback: What are professors saying about XP and unit testing? Is XP seen as incompatible with academic goals?
3️⃣ Systems Thinking in Action: Unpacking how a systems-thinking approach (holistic problem-solving) provides clarity on this issue.
4️⃣ The Runner Analogy: How comparing sprinters and cross-country runners sheds light on coding strategies.
5️⃣ Universities vs. Industry Needs: Are schools preparing students for industry or academic research? What should their goals be?
6️⃣ Degree Confusion: Why students struggle to navigate differences between computer science and software engineering programs.
7️⃣ Niche or Necessity? Why XP, a small sector of the software industry, may not get the spotlight it deserves in schools.
8️⃣ Unit Testing's Lone Survival: Is unit testing finding its way into classrooms, but XP is not?
9️⃣ The “Unknown Unknowns” Problem: What happens when students don’t even realize the value XP could bring to their careers.
🔟 Solutions That Work: Experiments and strategies we’ve used to promote XP in university curricula.
💡 Why This Episode Matters:
- Maintainability in Code: Discover why maintainability is crucial—not just in industry, but even for academic projects.
- Handling Resistance: Learn how educators can introduce XP despite opposition from traditional academic mindsets.
- Spotlighting Success: Shout-outs to universities doing XP right and what others can learn from them.
- Academia-Industry Collaboration: Insights from years spent on professional committees advocating for XP.
📌 Who Should Watch This Episode?
- Students: Discover why your curriculum may overlook XP and how to build the skills yourself.
- Educators: Get inspired to bring XP into your classrooms and navigate institutional challenges.
- Industry Professionals: Understand the gap between academia and industry, and what it means for hiring new grads.
Join us as we explore the challenges and opportunities of integrating XP into education. With actionable insights, engaging analogies, and practical advice, this episode is packed with ideas to spark change.
Video and Show Notes: https://youtu.be/CidbB_SBGl0
In this thought-provoking episode of the Mob Mentality Show, we are joined by Ariel Pérez to explore the fascinating intersection of Complex Adaptive Organizations, Organizational Topologies, and the FAST Agile Framework. Together, we dive into the challenges and opportunities of modern software development and organizational dynamics, offering actionable insights for leaders, teams, and anyone navigating complexity in their work.
Highlights from the Episode...Complex Adaptive Organizations and FAST Agile:* Manufacturing vs. Software Development: Why building the same product repeatedly differs from creating custom software . * Complexity Theory in Software Development: How unpredictable side effects shape outcomes and the pursuit of predictability in organizations. * Fixed Scope and Fixed Date: Are they real business needs, or just external motivators? What are their long-term impacts on quality and delivery? * Theory X vs. Theory Y (management theories): How a leaders' management principles and practices influence autonomy, trust, and collaboration. * Dynamic Teams in FAST Agile: The pros and cons of adapting teams dynamically to match work needs versus forcing work into rigid team structures. * Story of Transitioning to FAST: A tale of initial resistance to the FAST Agile approach and the eventual embrace of its benefits.
Building a Culture of Experimentation and Learning:* Experimentation as a Foundation for Innovation: How to test hypotheses in product development and team practices without compromising quality. * From Fear to Trust: Encouraging experimentation in new teams or under new leadership while creating safety for bold ideas. * Practical Experiments: Implementing small feature flags, A/B testing (comparing two versions in production), and time-limited trial runs to foster innovation. * Respect and Radical Candor: Building trust through open communication, mutual respect, and the occasional dose of healthy banter 😅.
Risks and Controls: A Never-Ending Game of Whack-a-Mole:* Balancing Risk and Control: How risk-heavy environments lead to more controls (e.g., CAB—Change Advisory Board, PR—Pull Request) and the ripple effects of other risks these controls create. * Holistic Thinking: Why addressing one risk often introduces others and how to manage risk without stifling agility. * Mob Programming as a Solution: Handling emergency changes safely and collaboratively without falling into the trap of excessive gatekeeping.
Key Takeaways:* Embrace complexity and adapt dynamically to navigate unpredictable challenges. * Optimize for learning through experimentation and apply these insights to real-world problems. * Avoid control-heavy environments that stifle innovation and agility by thinking holistically about risks.
Join us as we unpack these ideas and share strategies to foster a responsive, trust-based culture in your teams and organizations.
🎧 Don’t miss this episode! Subscribe to the Mob Mentality Show on your favorite platform: https://www.mobmentalityshow.com/
FYI: Video and more show notes: https://youtu.be/ghzOSV4waIo
Is some refactored code truly better—or is it just a matter of taste? In this episode of the Mob Mentality Show, we explore the debate: Is some refactoring a subjective preference or an objective improvement?
Join us as we dive into the fascinating world of refactoring, where code quality, team dynamics, and even artificial intelligence (AI) come into play. Here’s what we discussed:
- The Ice Cream Debate: The story of a team/mob navigating a series of refactorings and asking, Are these changes about style, like preferring chocolate over vanilla? Or is there an objective improvement in the code?
- Cognitive Load, Cyclomatic Complexity, and More: How refactored code impacts key factors like cognitive load (mental effort required to understand code), cyclomatic complexity (a measure of the number of independent paths through a program), readability, and maintainability.
- Copilot AI's Take: Results of analyzing “before and after” versions of refactored code using Copilot AI (a large language model or LLM trained for coding). Does the AI agree with human developers?
- Gray Areas vs. Black-and-White Decisions: How much of refactoring is clear-cut improvement versus a matter of debate?
- Coaching Through Disagreements: Strategies to coach a team through potentially heated refactoring disagreements. Should you stick to principles or let the team run experiments in production against the principles?
- Decision-Making Tactics: How to align on contentious refactoring decisions. Should you flip a coin, follow a guiding principle, or defer to team consensus?
- Principles and North Stars: Identifying which coding principles matter most to your team and using them as a decision-making anchor.
- Dealing with Apathy: How to engage team members who are indifferent to coding principles and quality debates.
- 7 Habits of Highly Effective People: Applying Stephen Covey’s timeless principles to facilitate productive refactoring discussions and team collaboration.
- Diversity of Opinion as a Strength: Embracing different perspectives to make your team or mob/team stronger and more innovative.
- Radical Candor vs. Safe Experiments: Balancing direct feedback with the freedom to experiment—even if it means running tests in production.
- “Stop the Line” Moments: Deciding when a refactoring disagreement is serious enough to halt progress versus letting safe experiments play out.
Whether you’re a developer, team lead, or software architect, this episode is packed with insights to improve your approach to refactoring and team dynamics.
👉 Don’t miss this thought-provoking discussion!
Video and Show Notes: https://youtu.be/s2bl7dFAIV0
What happens when teams, codebases, or systems scale beyond their limits? In this thought-provoking episode of the Mob Mentality Show, we tackle this hyperbole: “Is scaling the root of all evil?” We explore how the challenges of scale—in team size, code complexity, and even societal structures—might be the culprit.
💡 Key Discussion Points:
- Defining Scale Across Contexts: How does scale impact teams, classrooms, codebases, and more?
- Innovation vs. Scale: Does scaling stifle the spread of good ideas, principles, and practices (e.g., in law, culture, or workplace norms)?
- Interpersonal Challenges: Why do interpersonal problems grow exponentially in larger groups?
- Code Quality and Scale: Does a larger codebase inherently lead to lower quality?
- Focus and Attention: How does scale dilute individual and team focus? What happens to attention in scaled systems?
- Second-Order Effects: Are rigid systems designed to handle scale unintentionally creating harmful side effects—and even side effects of those side effects?
- Experimentation and Innovation: How do rigid systems inhibit experimentation, and why does this matter for growth and innovation?
- Descaling as a Solution: Are the best solutions to scaling problems simply about reducing scale?
- Inverse Conway Maneuver: Exploring this organizational design concept and its relevance to scaling.
- Lessons from Coaching: How scaling challenges in youth baseball practices compare to leading software development teams.
🎯 Why You Should Watch/Listen
This episode touches on the consequences of uncontrolled growth, from technical issues in software engineering to cultural and organizational challenges. Learn why "descaling" could be the key to improving focus, quality, and innovation in your team or organization. Plus, discover how mobbing (collaborative software development) naturally counters the pitfalls of scaling.
📢 Don’t miss out! Subscribe now on your favorite platform: https://www.mobmentalityshow.com/
Video and Show Notes: https://youtu.be/YLeyRHcI-eI
Join us in this exciting episode of the Mob Mentality Show as we dive deep into the fascinating intersection of mob programming, neuroscience, and team dynamics with the insightful Mike Bowler! Mike brings over a decade of experience facilitating mob programming sessions across hundreds of teams and countless experiments. Whether you're a software developer, team coach, or collaboration enthusiast, this conversation will leave you with actionable insights and inspiring takeaways.
🔍 What We Discuss:
- A Different Approach to Facilitating Mob Programming Sessions
- The Neuroscience of Psychological Safety and Mobbing
- Team Flow States and Brainwave Activity
- About Mike Bowler
📢 Don’t Miss Out!
Subscribe to the Mob Mentality Show on your favorite platform to learn more about innovative collaboration techniques and team success.
🔗 Find us here: https://www.mobmentalityshow.com
Video and show notes: https://youtu.be/okeAxvRggVc
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.
💡 Want to stay ahead in your software journey? Don't miss this deep dive into the cognitive, emotional, and technical aspects of reading code.
🔗 Subscribe to the Mob Mentality Show:
Get notified as soon as this episode drops! Available on all major platforms:
👉 https://www.mobmentalityshow.com/
🎧 Tune in to unlock new paradigms for code reading and refactoring. Let’s move from fear to flow together!
Video and Show Notes: https://youtu.be/pXEp6jBeycs
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!
FYI: Video and show notes to be posted here in the next day or so.
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.
🔑 Key Topics Discussed:
-
Chesterton's Fence: Learn the origin and meaning behind Chesterton's classic quote: "The more modern type of reformer goes gaily up to it and says, 'I don't see the use of this; let us clear it away.' To which the more intelligent type of reformer will do well to answer: 'If you don't see the use of it, I certainly won't let you clear it away. Go away and think. Then, when you can come back and tell me that you do see the use of it, I may allow you to destroy it.'" Discover why this concept is critical in both software development and team culture.
-
Applying Chesterton’s Fence to Code: We walk through a real-world example of legacy product code. Should you refactor, delete, or preserve existing code? Explore how understanding the original intent of code, especially in larger systems, can prevent costly mistakes.
-
When to Delete Unit Tests: What happens when a unit test no longer seems relevant or helpful? We explore how the Chesterton's Fence principle applies to testing, discussing whether old tests should be removed or maintained, and how to balance thoroughness with agility.
-
Five Monkeys Experiment: Chris Lucian shares insights from the famous psychological experiment that demonstrates how practices can become entrenched even when the original purpose is long forgotten. This complements the discussion of Chesterton’s Fence by examining how some habits and behaviors persist without rationale. We discuss strategies for assessing when it's time to dig deeper or when it's acceptable to move forward without full understanding. While it's important to understand why something exists, can too much time be spent analyzing before making changes?
-
Domain-Driven Design (DDD) and Behavior-Driven Development (BDD): We explore how principles from DDD and BDD can help teams bake the purpose and intent directly into code, making it easier to understand why a particular rule, function, or test exists in the first place.
By the end of the episode, you’ll gain a deeper understanding of how Chesterton’s Fence and the Five Monkeys Experiment apply to your day-to-day decisions in software development, testing, and even team dynamics. Whether you’re dealing with legacy code, outdated tests, or long-standing team practices, this episode provides practical insights to help you make thoughtful, informed decisions.
🎥 Subscribe and Stay Updated: Don't miss this insightful episode! Be sure to subscribe to the Mob Mentality Show on your favorite podcast platform or YouTube.
Video and Show Notes: https://youtu.be/a2bdNOsM_r0
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
In this episode of the Mob Mentality Show, we explore the unintended consequences and pitfalls of relying too heavily on metrics with a dive into Goodhart’s Law. If you’ve ever wondered why well-intentioned measurements can backfire and cause harmful behaviors in software development, leadership, and beyond, then this episode is for you!
What is Goodhart’s Law?
Goodhart’s Law states that “When a measure becomes a target, it ceases to be a good measure.” This means that when metrics are used as goals, people tend to optimize for the metric itself rather than the underlying value or outcome it represents.
How Can Metrics Destroy Collaboration?
Chris shares an intriguing story about two teams set up to compete against each other, only to find that the focus on “winning” metrics led to a breakdown in communication and collaboration. Instead of fostering teamwork, the metrics created silos and a toxic environment.
Examples of Bad Metrics in Software Development
We go through specific metrics that have led to bad behaviors in software teams, such as:
- Test Coverage Metrics: How a narrow focus on test coverage can lead to tests that do nothing but improve the metric, without actually asserting anything or improving software quality.
- Points-per-Person Metrics: Why measuring productivity at an individual level (e.g., story points completed per person) damages team dynamics and led to cutting corners.
Are There Any Good Metrics?
Is it possible to use metrics without falling into the Goodhart’s Law trap? We discuss whether certain collective measures like DORA Metrics can provide value without the same issues.
Metrics for Conversations, Not Evaluation
One key takeaway is the distinction between metrics that trigger healthy conversations vs. those used to make evaluative judgments of a team from a distance. When metrics become evaluative rather than formative, they risk distorting behaviors and eroding psychological safety.
Leading Measures vs. Lagging Measures
We also touch on insights from The 4 Disciplines of Execution and its perspective on leading measures vs. lagging measures.
Managing Teams and Incentives at Scale
Finally, we tackle the challenge of managing people and teams at scale. Incentive structures that overemphasize metrics can lead to counterproductive behaviors, burnout, and loss of motivation. We emphasize the anti-pattern of metrics-driven management without side-by-side in-context coaching.
If you’ve ever experienced the pitfalls of metrics-driven environments or are seeking ways to improve measurement practices in your teams, this episode is packed with lessons learned, cautionary tales, and actionable advice. Don’t miss it!
Video and Show Notes: https://youtu.be/MiySzmDRYA8
In this insightful episode of the Mob Mentality Show, we sit down with Michael K Sahota to dive deep into the transformative power of Mob Programming and Pair Programming in dissolving the ego and enhancing team dynamics. Michael shares his unique perspective on how mobbing/pairing can lead to profound psychological shifts, ultimately boosting team function, empathy, and humility.
Key Highlights:
Pair/Mob to Dissolve the Ego and Increase Team Function
- Michael discusses the primary goal of a mob or pair session, revealing how it goes beyond just writing code or learning new techniques. It’s about dissolving the individual ego and fostering a collective, empathic mindset that benefits the entire team.
- We explore Michael’s personal journey with his ego, offering a candid look at how pairing/mobbing have helped him grow both personally and professionally.
- What is the most significant outcome of mobbing/pairing beyond the immediate code or learning? Michael explains how the real magic happens when team members listen to each other and take turns, creating a powerful forcing function for collaboration and psychological safety.
- We dive into the psychological processes that occur during mobbing, including the death of "fear-based clinging" and how healing the ego leads to deeper empathy and humility. Michael offers anecdotes on how mobbing helps resolve internal conflicts and improve relationships—both at work and beyond.
- How much time should be allocated for production versus focusing on production capability? Michael discusses how to strike the right balance between learning and output, avoiding over-indexing on either side.
- A unique "learning theft" example highlights why juniors should be prioritized during experiments, while senior developers are encouraged to go last—except when it comes to admitting mistakes, where the inverse applies.
Pair/Mob for Production Capability and Beyond
- Michael shares his thoughts on balancing the development of production capability with immediate production needs. He explains how overinvesting in production at the expense of capability can destroy long-term results.
- We explore how improving production capability with a solid ROI can often yield results within a quarter, but must be continually nurtured through retrospectives and lean thinking.
- Breaking the cycle of overinvesting in production under intense pressure is a major challenge for many teams. Michael shares stories of how transparency in communication, both within and outside the team, can help break this cycle.
- Michael introduces the concept of building culture bubbles and we share contrasting ideas on how much courage is needed for these bubbles.
- We also discuss the HIPPO effect and how mobbing can disrupt this dynamic by emphasizing experimentation and collective decision-making rather than deference to authority.
- Finally, Michael ties it all together by emphasizing the role of humility. No one is a flawless expert, and through mobbing/pairing, teams can build a habit of asking for help and embracing the idea that everyone, regardless of experience, has something to learn and improve.
Why You Should Watch:
This episode is a must-watch for anyone involved in software development, team dynamics, or leadership. Whether you're interested in improving psychological safety, fostering team empathy, or enhancing production capability, Michael K Sahota's insights on mobbing and ego dissolution will help you rethink how teams work together. It’s about more than code—it’s about creating a culture of trust, engagement, and continuous improvement.
Video and Show Notes: https://youtu.be/Wj2hYGMei8s
In this episode of the Mob Mentality Show, we are excited to have Dave Copeland share his experiences in the world of agile development, focusing on the critical nuances behind well-known principles such as SRP (Single Responsibility Principle), YAGNI (You Aren’t Gonna Need It), DRY (Don’t Repeat Yourself), and the often-debated #NoEstimates approach. Drawing from his journey transitioning from government waterfall projects to agile methodologies at a startup, Dave kicks off a discussion with invaluable lessons on how teams can avoid misunderstanding and misapplying agile aphorisms, or avoid the pitfalls of following agile aphorisms too woodenly.
The Dangers of Following the Literal Words of Agile Aphorisms?
Have you ever seen a team stuck arguing over what SRP or SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) truly means? Dave explains how teams can misinterpret these catchy phrases, leading to confusion, low cohesion, improper coupling, and poor decision-making. We dive into real-world examples from Dave’s experience, discussing when it's okay to duplicate code and when it's not, the delicate balance between over-engineering and under-engineering, and the importance of nuance in agile practices.
"Just Sharing" vs. Universal Recommendations
Is it wise to blindly follow every "recommendation" from an agile coach, or is there room for discussion, experimentation, and adaptation? With Dave we tackle the common issue of semantic diffusion. We explore how teams can navigate complex situations and adapt agile and lean principles to their unique contexts.
Organizational Change and Safe Learning Environments
We bring in the “Reading Rainbow” analogy and other examples to illustrate how organizational change needs to be gradual, allowing for nuanced learning. We also emphasize the importance of creating an environment where team members can safely fail while being guided by experienced developers in real-world contexts. Whether you’re scaling a team or trying to stack the deck with the right mix of skills, actionable strategies for fostering growth are discussed.
Estimates, #NoEstimates, and Dealing with Uncertainty
The conversation gets even more interesting as we delve into the jarring #NoEstimates and its sometimes misunderstood implications. Dave brings up valid situations with real deadlines (e.g., seasonal deliveries, regulations) and we weigh-in on ways to handle them with or without estimates that are less likely to lead to self-sabotage. We also discuss the impact of automation on estimates, and what terms like "estimate" really mean.
Continuous Delivery (CD) also takes center stage as we discuss examples of how it and the practice of "don't sell what you don't already have built" fosters trust and reduces uncertainty. We touch on the various unknowns that can arise in development, how CD can help mitigate them, and whether teams can benefit from an "#OptionalEstimates" mindset. Throughout, Dave provides practical advice on aligning practices with business goals and managing risks effectively.
Coaching, Coding, and Higher-Level Roles
Finally, we explore Dave’s thoughts on balancing hands-on coding with coaching responsibilities, especially in higher-level roles. How do you set expectations for coaches, and how can team composition shape the effectiveness of good practices? Whether you’re actively writing code or stepping back to guide others, Dave shares examples for making both approaches work.
Don’t miss this episode packed with deep dives into agile practices, team dynamics, and nuanced leadership. Be sure to subscribe to the Mob Mentality Show on your favorite platform to catch this episode and others like it!
Video and Show Notes: https://youtu.be/IPFYe_oOFtI
In this episode of the Mob Mentality Show, we explore the profound impact of mob programming from a management perspective with our special guest, Rickard Westman. With a diverse background in sports and news software products, Rickard transitioned from a traditional solo work environment to embracing mobbing—a journey that radically transformed how teams communicate, collaborate, and deliver value.
Rickard opens up about his early experiences in the industry, where he witnessed the drawbacks of isolated work patterns—particularly the delays and inefficiencies caused by waiting on pull requests. His initial encounter with mob programming was anything but smooth. The concept felt awkward and unnatural, but after Woody Zuill’s workshops and after experimenting with mobbing, Rickard and his teams discovered its potential to revolutionize their workflows.
In this episode, we dive into Rickard's journey from skepticism to advocacy for mob programming. He shares how mobbing helped increase production release frequency and enhance safety within his teams. By exposing communication breakdowns and dependency issues during scaling, mob programming brought to light the hidden challenges that were stalling progress. With the introduction of multiple mob teams, these issues began to dissipate as team members naturally shared knowledge and collaborated across different areas.
One of the key insights Rickard offers is the importance of slack in the system, generated through effective teaming. This slack led to greater autonomy, smoother flow, and quicker resolution of bottlenecks. Rickard recounts a compelling story where a bug fix, which would have taken six weeks in the traditional setup, was resolved in just one day through mobbing. This rapid turnaround is a testament to the power of collective problem-solving and the deep, holistic understanding of the product that mobbing fosters among team members.
Rickard also touches on the shift in management responsibilities as a result of mob programming. With teams becoming more self-organizing, managers found themselves spending less time overseeing individual tasks and more time empowering their teams to make decisions. This distributed decision-making model, contrasted with the traditional command-and-control approach, aligns with principles from the book Turn The Ship Around.
Throughout the episode, we discuss the benefits and potential pitfalls of mob programming from a management perspective. Rickard emphasizes the importance of coaching mob members to understand their contributions, especially when not working solo. He also explores how successful mob teams can serve as models for new teams, highlighting different interaction patterns for product owners, analysts, and even sports writers.
Finally, we examine the meta-level impact of mob programming at the C-suite level and how it influences broader organizational decision-making. Whether you're a manager, developer, or team member, this episode provides valuable insights into how mob programming can unlock potential, foster collaboration, and drive continuous improvement in your organization.
Video and Show Notes: https://youtu.be/hLN2iCBdYac
It's back to school, everyone! Dive into a transformative journey of education with Matthew Philip, an experienced Organizational Refactorer and educator, as he shares his innovative approach to integrating XP (Extreme Programming) and Agile methodologies into the classroom. In this episode of the Mob Mentality Show, we explore how Matthew's dynamic teaching methods are applied to software engineering education, fostering an environment where trust, mastery, and psychological safety are paramount.
XP and Agile in the Classroom
Matthew Philip's unique perspective as both an educator and coach provides a compelling narrative on how XP and Agile principles can be implemented in higher education. From his history of teaching Agile in orgs and universities to leading hands-on learning experiences that go beyond traditional lectures, Matthew's methods challenge the conventional constraints of the classroom.
Discover how Matthew creates a WAR room environment in the classroom, fostering high energy and positivity to encourage active participation. Learn about the use of information radiators, pairing, and mob programming to ensure students not only grasp theoretical concepts but also excel in real-world applications. Matthew also delves into the challenges of teaching Agile content as part of a master's program in software engineering, where students are exposed to the intricacies of refactoring to patterns and leading through facilitation.
In this episode, we discuss the critical differences between being a crafter versus just a coder, and how Matthew helps students navigate the transition from the academic world to the corporate environment. We explore the importance of understanding short-term school code versus long-term maintainability, and how working with real customers in a classroom setting can profoundly impact students' learning experiences and feedback loops.
Mastery-Based Learning and Psychological Safety
Matthew is a strong advocate for mastery-based learning, where the focus shifts from simply passing quizzes to deeply understanding and applying knowledge. We discuss how students can assess their own understanding, whether through techniques like Test-Driven Development (TDD) or experiencing the consequences of poor practices. Matthew emphasizes the significance of psychological safety in the classroom, where students learn how to fail safely and collaborate effectively.
Explore how the pressure of pacing in large classrooms can conflict with mastery learning, and how assessment strategies can be adapted to ensure that learning sticks and isn't lost over time. Matthew shares insights on fostering peer assessments and creating systems where even when students "game" the system, true mastery is still achieved.
The Role of AI and Future of Education
In a rapidly evolving educational landscape, Matthew addresses the impact of generative AI in the classroom. How can AI be leveraged to enhance learning, and what are the risks of its misuse? We discuss the importance of correct prompting, the authenticity of AI-generated content, and whether mob programming could be the solution to these challenges—while also questioning whether this approach could disrupt current educational and industry standards due to teacher-to-student ratios.
Psychological Safety and Building Trust
Finally, we delve into the role of psychological safety in the classroom, exploring how activities like group juggling can teach students to fail and learn together. Matthew shares strategies for establishing trust and the correlation between high energy, positivity, and psychological safety. We also consider whether in-person interactions are essential for fostering trust, or if remote environments can replicate these conditions.
Don't miss this episode as we uncover the future of education, one where trust, mastery, and psychological safety take center stage. To stay updated on this and other insightful episodes, subscribe to the Mob Mentality Show on your favorite platform.
Video and show Notes: https://youtu.be/IkqRI2GQ4MY
In this episode of the Mob Mentality Show, we explore the intricate landscape of Automated Quality Gateways and Cross-Discipline Firmware Mobs with our guest, Cyrus Metcalf. This conversation is rich with practical insights and actionable strategies for anyone engaged in software, firmware, or hardware development, particularly those interested in enhancing team collaboration and continuous delivery (CD) practices through mobbing techniques.
Automated Quality Gateways:
Cyrus shares his experiences in setting up automated quality gateways for firmware and software that control sophisticated systems like boats. Learn how these gateways, including tests, formatting, and coverage, ensure robust code quality and seamless operations. We discuss the merits of running formatters locally versus within a pipeline. We also discuss the impact of these gateways on agility, depending on whether you’re in a startup or a more established organization.
The conversation includes the role of hardware abstraction layers and how automated quality gateways can supplement and even replace certain types of human feedback, thereby streamlining the development process. Cyrus also provides insights into achieving consistent formatting, the challenges of fine-tuning formatters, and the importance of custom config files. Discover how these practices create “highways” for development teams, enabling them to operate at peak efficiency within a fast red-green-refactor cycle.
Leveling Up Through Mobbing:
We also discuss how mobbing techniques can elevate the skills of every team member, regardless of their technical background. Cyrus explains how mobbing demystifies the development process, reducing their apprehension about software complexities. By fostering a collaborative environment where everyone learns a bit of everything, mobbing helps dismantle knowledge silos and promotes a culture of continuous improvement.
Cyrus shares his experiences as the sole software developer in a company, including strategies for using mobbing to educate and collaborate across hardware, firmware, and software teams. We explore the dynamics of cross-discipline mobs, where diverse teams work together on complex challenges, and how these mobs have evolved from training tools into essential parts of the production process.
The Culture of Mobbing:
The episode also delves into the cultural aspects of mobbing, including the pros and cons of different mob cultures across various companies, the importance of openness and inclusivity, and methods for resolving disagreements within a mob. Cyrus discusses the benefits and challenges of mobbing with juniors and interns, interacting with skeptics, and how a culture of openness—both within the mob and across the organization—can drive innovation and collaboration.
Lastly, Cyrus offers his perspective on how agile principles and practices have naturally integrated into his teams without the need for an official agile coach. This episode is essential listening for anyone looking to improve their team’s efficiency, collaboration, and overall quality through the integration of automated quality gateways and cross-discipline mobbing.
Video and Show Notes: https://youtu.be/vOxFEtX541A
In this episode of the Mob Mentality Show, we explore the Behavior Framework with the insightful Doc Norton, exploring the foundational behaviors that drive successful software development teams. Drawing from years of experience and real-world examples, Doc shares the principles and practices that have consistently helped teams deliver software products that are not only desirable but also viable and feasible.
Know the Problem You Are Solving
We kick off the discussion by tackling one of the most critical aspects of software development: understanding the problem you're trying to solve. Doc explains why it's not enough to have a manager dictate tasks and why teams must be aligned on the domain or specific set of problems they're addressing. We explore the difference between developers who are "builders" versus those who are "problem solvers" and discuss real-life scenarios where solving the root business problem either succeeded brilliantly or failed miserably. This section also delves into the concept of "Hubris Driven Development" and ties it into the importance of continuous validation before, during, and after development.
Make Your Work Visible
Next, we examine the significance of making your work visible. But what does that really mean? Doc challenges the notion of simply having a manager observe the development process and instead advocates for meaningful visibility that enhances awareness of flow, cycle time, and throughput. We discuss how much visibility is necessary and how to reduce the friction in data gathering by automating the process, ensuring that "updating status" doesn’t become an additional burden on the team.
Favor Automation Over Documentation
Doc takes us through the benefits of favoring automation over documentation. From auto-generating status reports via code commits to AI, to using Behavior-Driven Development (BDD) to create historical Gantt Charts, we explore how automation can ease developer pain and streamline DevOps engineering. This approach not only saves time but also enhances accuracy and consistency in reporting.
Work Together
The conversation then shifts to the evolving meaning of "working together" in modern software development. Doc reflects on how teams used to function without strict roles or specialization and how the industry's shift towards hyper-specialization has created silos and Lean wastes. We share stories of Pair/Ensemble Programming, the impact of certificate mills on over-specialization, and the pros and cons of specialization in Agile teams. Doc also discusses the importance of credibility through collaboration rather than positional authority and shares examples of teams successfully filling roles collectively.
Create Simple Things in Small Steps
Finally, we emphasize the power of creating simple things in small steps. Doc highlights the importance of being aware of psychological WIP (Work in Progress) limits and shares a story of how reducing lead time by taking small, simple steps enabled early and accurate validation. We also discuss the dangers of overproduction and the challenges faced when big steps lead to troubleshooting nightmares, all while tying it back to being meticulous about composition.
Don't miss out on this deep dive into the Behavior Framework with Doc Norton—packed with practical insights and actionable advice for anyone involved in software development.
FYI: Video and show notes to be posted here in the next day or so.
In this episode of the Mob Mentality Show titled "Nothing in Tech Matters Except XP? A Hot Take," We take on the controversial discussion of the ever-changing landscape of technology and the role of Extreme Programming (XP). Are industry "best practices" in languages, front-end frameworks, and meta-architecture mere trends destined to fade away? Come hear a provocative stance that challenges the importance of these things, arguing that they are volatile, trendy, and often miss the mark when it comes to delivering true software excellence.
We explore how many tech trends are built on the assumption that developers will inherently write unsafe code unless they are constrained by strong type systems, impenetrable boundaries (like microservices), and restrictive frameworks. But what if consistently following XP principles makes these safeguards superfluous? Can language, frameworks, tools, and even meta-architectures lose their high significance when XP is at the core of software development?
Throughout the episode, we draw on personal experiences, asserting that our developer satisfaction remains consistently high when XP values and principles are the guiding force, regardless of the technology stack. Without good XP practices, even the most advanced tools can't solve the deeper, underlying problems that plague software projects.
We delve into the ongoing debate of Majestic Monolith vs. Microservices, questioning whether the choice of meta-architecture matters as much if XP is practiced. How do these choices affect agility, and can agility be seen as a reward for technical excellence?
Another key topic is the influence of societal factors on willpower and habits, and how these meta-problems impact developers' ability to consistently follow XP practices. Can a focus on XP help overcome the challenges posed by trendy tech choices and shifting industry standards?
Chris poses a utopian question: If everyone adhered strictly to XP principles, would other factors like programming language, framework, or meta-architecture even matter? We explore this thought experiment, considering whether an XP-driven world could render other tech decisions less critical.
But it’s not all theory. Austin reaches out to Chris for "Apathy Counseling" for developers facing burnout or disillusionment with tech trends, and offers community analogies linking dev health to "Tech Dishes"—a metaphor for the routine maintenance needed to keep your codebase clean and healthy.
Finally, we tackle the nuances of infrastructure and database management, offering qualifications on the time and effort needed to support different setups. Whether you're grappling with microservices or maintaining a monolithic architecture, the focus remains on how XP can guide you through these challenges.
Don't miss this thought-provoking episode that pushes the boundaries of conventional wisdom in tech.
Video and Show Notes: https://youtu.be/MZUUemSJMjs
Come dive into the transformative world of Cross Discipline Causal Loop Diagramming on this episode of the Mob Mentality Show! Unveil the principles and practices behind generating organization-wide understanding and breaking down cross-functional misunderstandings that often lead to missed opportunities.
Key Highlights:
1. The Cost of Misunderstanding: Discover how cross-functional misunderstandings can lead to missed opportunities and inefficiencies. We explore real-world examples and offer practical solutions to bridge these gaps.
2. Insights from "The 5th Discipline": Learn from the wisdom of Peter Senge's seminal book, "The 5th Discipline". Understand how systems thinking can revolutionize your organizational dynamics and foster a culture of continuous improvement.
3. Causal Loop Diagramming 101: Get a clear definition of causal loop diagramming and its critical role in understanding complex adaptive systems within organizations. See how quantities in a system impact each other through balancing and reinforcing loops.
4. Breaking Down Knowledge Silos: Address the dangers of over-reliance on specialists and knowledge silos. Learn how causal loop diagramming can facilitate better communication and collaboration across different functions and departments.
5. Visualizing Complex Systems: Grasp the importance of visualizing exponential effects and cause-and-effect patterns that enhance the performance of typically separately managed systems.
6. Practical Examples and Tools: Dive into examples from a Fifth Discipline book club and understand how to draw and use causal loop diagrams. Explore tools and techniques that make the process accessible and effective.
7. Real-World Applications: Hear about a causal loop diagram example related to bad code quality and how pairing with each part of the system can build a comprehensive system diagram. Understand the impact of psychological safety on system self-awareness.
8. Interdepartmental Impact: Discuss the importance of seeing the whole system to understand interdepartmental impacts. Compare the efficacy of having the whole system in the room with and without formal tools.
9. Addressing Second-Order Effects: Identify and address second-order effects and human shortcomings in seeing side effects of side effects. Learn how diagramming can help deal with the chunking problem of a large system.
10. Feedback and Future Learning: Hear feedback from Big Agile session participants and understand the learning path for drawing and using causal loop diagrams. Discover how mob/pair causal loop diagramming can enhance understanding and problem-solving.
Join us as we uncover the power of causal loop diagramming to aid decision making, improve communication, and foster a culture of collaboration and continuous improvement. Don't miss out on this edifying episode!
Ensure you stay engaged in the world of organizational development and systems thinking by tuning in to this episode. Your learning path for causal loop diagramming and breaking down knowledge silos starts here!
FYI: Video and show notes to be posted here in the next day or so.
Join us in this thoughtful episode of the Mob Mentality Show as we explore the world of Lean Software Development with Dave Adsit. Titled "Crafting Lean Software: Dave Adsit on Small Batches and Short Lead Times," this episode provides valuable insights for those looking to enhance their software development values and practices. Dave Adsit shares his experiences on how to effectively implement lean principles to achieve small batches, short lead times, and frequent releases.
Key Discussion Points:
Lean Software Development
- Craft vs. Engineering
- Principles of Flow
- Waterfall vs. "Agile" vs. Lean
- Timeboxes vs. Scope-Boxes
- Resource vs. Flow Efficiency
- Prioritization, Prototyping, and Lean Investment Bets
- Single Piece Flow, Feature Flags, Continuous Delivery
- Maximal Learning through Experimentation and a 50% Product Bet Success Rate
Collaboration
- Integration with Lean
- "All Hands on Deck" Mindset
- Relation to WIP Limits
- Pair and Mob Programming
- Failures and Lessons
- Rules, Why, and Learning Paths
- Utilization and Person vs. Team vs. System Value
Continuous Improvement
- Core Value
- Innovative vs. Inert Practices
- Deep vs. Shallow Learning
- Leading Learning Opportunities
- Knowing Enough to Make Informed Decisions
- What If Some Do Not Want to Learn?
- Rock Star vs. Super-Star
FYI: Video and show notes to be posted here in the next day or so.
Join us on the Mob Mentality Show as we sit down with the insightful Artie Gold to explore the pivotal role of scope and cognitive load in coding. In "Artie Gold on Scope is Your Friend: The Less You Need to Know at Any Given Moment, the Better," we delve into practical strategies for enhancing productivity and code quality through smart scope management.
Scope and Cognitive Load
Artie Gold sheds light on the false pride developers often take in handling complex code and high cognitive demands. We discuss the advantages of understanding as needed versus knowing everything at once. Are developers truly like acrobats, balancing multiple logic threads simultaneously? Artie highlights the human mind's limitations and the significant benefits of encapsulation in reducing cognitive load.
Key topics include:
- The detrimental effects of high scope and cognitive load on development
- Encapsulation's role in making code easier to read, scan, and modify
- Comparing agile, nimble, and shallow approaches to manage cognitive overload
- Artie's amusing analogy of low-level code instructions to a simple task like buying milk
- Strategies for helping developers adapt to a new paradigm of encapsulated code reading
Clarity of Value on Stories
We shift our focus to the critical importance of clarity in user stories and the benefits of direct client relationships. Artie discusses the drawbacks of indirect communication and the often humorous complications of serving as the middleman for another middleman.
Discussion points include:
- The irreplaceable value of direct conversations in understanding "the why" behind requests
- Whether good story conversations can be replaced with a template or checklist
- The impact of user feedback on delivered products versus theoretical future products
- The risks of over-refinement, illustrated by the rock versus ruby MVP delivery example
- Challenges in assuming everyone excels at written communication
Code is Everything. Code is Nothing.
In our final segment, we explore the dual nature of code. Code is vital—it produces value, is easier to change than other components, and serves as a repository of knowledge. Yet, code alone is meaningless without context and purpose.
Artie elaborates on:
- The necessity of keeping code in good shape for ease of future changes
- Why "pretty" code isn't the goal—functional, adaptable code is
- The inherent truthfulness of code as the ultimate source of software reality
Don't miss this insightful discussion with Artie Gold that can transform your approach to coding, user stories, and the fundamental nature of software development.
Video and Show Notes: https://youtu.be/0z2nQHT8Jvs
In this compelling episode of the Mob Mentality Show, we dive deep into the art of Sticky Mob Programming with Lennart Fridén, who brings a wealth of knowledge from his decade-long journey coaching mob programming in Sweden. Whether you're a seasoned mob programmer or new to the concept, this episode is packed with actionable insights and real-world examples that can help you make mobbing a lasting fixture in your team's workflow.
Key Discussion Points:
Sticky Mob Programming:
- Lennart’s insights on mob stickiness
- Beyond just trying mobbing
- Persistent mob habits even without the nudging of a coach
- Mob stickiness challenges and triumphs
- Roles: outsider, insider, first follower (AKA eager first dance partner),
- Lessons from "Power of Habit"
- Mob as keystone habit leading to a cascade of other beneficial practices
- Community and belonging
- Dealing with stagnation
- Vulnerability and growth
Technical Coaching and Redundancy:
- Embedding coaching and making the coach's role redundant (times two)
- Teaching for sustainability
- Gradual coach transition examples
- Handling eager vs. apathetic first follower (potential future coach)
P.S. Reach out to Lennart Fridén ( https://www.linkedin.com/in/lennartfriden/ ) for guidance on introducing mobbing and ensuring it sticks in your organization.
Tune in to discover how to make mob programming a sticky and sustainable practice in your organization!
Video and Show Notes: https://youtu.be/FSFyifwXbWo
Discover a transformative conversation on systems thinking with our special guest, Michele Sollecito, in this episode of the Mob Mentality Show. In "Michele Sollecito on Systems Thinking: Seeing the Interactions Beyond the Parts," Michele shares valuable insights and practical examples that will revolutionize your approach to system optimization and organizational management.
Topics Covered:
Systems Thinking:
- Seeing Systems Everywhere
- Focus on Interactions
- Person Issue vs. System Issue
- Animated Causal Loop Diagrams
- Sub-System Optimization
- System Fracturing from the Top
- Trunk Based Development (TBD)
- Benchmarking and "Copy-Paste" Pitfalls
- Defensive Posture vs. Experimentation
- Changing Core Beliefs
- Leadership and Fake Experiments
- Data vs. Emotion
- Comfortable Inefficiency
- Team Dynamics and Failure
- Culture of Continuous Improvement
- *Managing Resistance to Improvement
Software Architecture:
- Specialists vs. Generalists
- Technology Obsession
- Distributed Systems
- Coordination Strategies
- Paired Product Ownership
- Autonomy vs. Consistency?
Ensemble Programming:
- Resistance
- Paradigm Shift to Fun
- Early Adopters
- Collaboration and Virtue
- Sustainable Development
- Avoid Echo Chambers
- System Level Relationships with Mob
Don't miss this enlightening conversation that promises to transform your approach to systems thinking, software architecture, and ensemble programming. Listen and engage with Michele Sollecito's expert insights on the Mob Mentality Show!
FYI: Video and show notes to be posted here in the next day or so.
Join us on this enlightening episode of the Mob Mentality Show as we dive deep into the world of collaborative programming with our special guest, Eli Goodman from Tuple. In this episode we explore the intricacies of mob programming, the innovative tools designed for enhanced teamwork, and the future of Tuple.
Highlights from Our Discussion:
Eli's Mobbing Questions for Austin and Chris:
- Last Time Mobbed?
- Duration and Techniques
- Team Dynamics
- Austin's Recent Mob Journey
- Chris' Leadership and Mob Hopping
- Visualizing Connections
- Continuous Improvement and Diffusion of Innovation
- When to Mob and When to Not
Tools for Mob Programming:
- Popular Tools
- Monitor Usage
- Tech Enhancements
- Chat and Note Integration
- Equal Navigation and Code Verbalization
Inside Tuple:
- Eli's Role
- Origin Story
- Tuple's Progress
- Technical Excellence
- Social Layer Integration
- Resource Efficiency
- Focused Functionality
- User Base
- Future Prospects
This episode is a must-watch for anyone interested in mob programming, team collaboration, and cutting-edge tools that facilitate efficient and effective coding practices. Whether you're a seasoned mob programmer or new to the concept, Eli Goodman’s insights will provide valuable knowledge and inspiration for your programming journey.
Don't forget to like, comment, and subscribe for more episodes packed with valuable programming insights!
FYI: Video and Show notes to be posted here in the next day or so.
In this episode of the Mob Mentality Show, we dive into a challenge faced by many mobbers: the varying speeds of team members. Inspired by an X conversation in the community, we explore various possible experiments to run when someone in the ensemble says "The Mob Moves Too Slow for Me."
🔗 Join the Discussion:
- Link to Community Tweet: https://x.com/EnverBral/status/1789533801690825041
🔍 Key Topics Covered:
- Speeding Up the Mob: Should the mob match the speed of the fastest member?
- Constructive Feedback: Transforming into a feedback machine and coach to help the team grow and improve continuously.
- Utilizing Excess Brain Cycles: How to use spare mental capacity to build tools, automate tasks, and support the team's efficiency.
- Career Direction and North Star: Conversations on finding and aligning with your career goals and personal mission.
- Diverse Mob Roles: Leveraging roles such as forward-looking research while others focus on production to enhance team learning and speed.
- Effects of Working Alone: Understanding the side effects of working solo and how it impacts team dynamics.
- Temporary Splits: Exploring the benefits and drawbacks of splitting from the mob temporarily for specialized tasks and re-integrating.
- Impact of Decisions: The inevitability of being affected by others' decisions even when working independently.
- Deepening Knowledge Gaps: The risks of creating solutions that no one else on the team understands and how to mitigate this.
- High-Octane Collaboration: The advantages of co-locating with other fast-paced mobbers to enhance productivity.
- Natural Splits: When different personal missions lead to a natural division within the mob.
- System vs. Sub-System Optimization: Balancing the optimization of the whole system against focusing on sub-systems.
- Mob Programming Benefits: Understanding the financial benefits and ROI of mob programming.
- Voluntary Participation: The importance of not forcing team members to mob if they prefer other ways of working.
🔔 Subscribe & Stay Updated: Don't miss out on future episodes! Subscribe to the Mob Mentality Show for more discussions on enhancing mob programming, team dynamics, and maximizing productivity.
📢 Engage with Us: Share your thoughts and experiences in the comments below. Have you faced similar challenges in your mob programming journey? How did you address them? Let's learn from each other!
👍 Like, Share, and Comment: If you found this episode valuable, give it a thumbs up, share it with your network, and leave a comment. Your feedback helps us improve and brings more relevant content to you.
🔗 Connect with Us: https://www.mobmentalityshow.com/
Get ready for a deep dive into the intricacies of mob programming and discover how to harmonize varying speeds within your team while fostering a culture of continuous improvement and collaboration. Tune in now!
Welcome to the Mob Mentality Show! In this episode, "Mobbing in the Midst of Waterfalls," we explore how mobbing can survive and even thrive when surrounded by traditional waterfall teams. Full of practical insights, this episode is especially helpful for those navigating diverse workflows.
Topics Covered:
1. Mobbing in Lean/Agile vs. Waterfall
Learn the key differences and challenges, and how mobbing can bridge the gap between these methodologies.
2. Collective Automation
Discover how mob teams collaborate on automation and pipelines with waterfall teams to aid tech integration. Understand how mob teams can drive automation initiatives that benefit the entire organization.
3. WIP and Scope Negotiation
Master the art of negotiating WIP and thin slice scopes with waterfall teams.
4. Scheduling Mob Time
Find practical strategies to mob with waterfall team members, overcoming scheduling conflicts.
.5 Avoiding Bottlenecks
Learn how to support others and ensure smooth progress that prevent workflow congestion.
6. Rogue Lean Story
Hear a concrete story about maintaining lean principles within a waterfall framework. Discover strategies to fight for optimal cycle times.
7. Creative Solutions
Unlock innovative solutions by thinking of third alternatives to achieve business goals. Gain a clear understanding of business problems, ensuring flexibility and adaptability in tech solutions.
Why Listen?
This episode offers practical advice, real-world stories, and insights on maintaining mobbing techniques within waterfall environments. Tune in to balance agility and structure, foster continuous improvement, and drive successful automation across your organization.
Don’t miss this enlightening episode of the Mob Mentality Show – "Mobbing in the Midst of Waterfalls." Subscribe now!
Subscribe to the Mob Mentality Show on YouTube and your favorite podcast platforms for more insightful discussions and advice.
Video and show notes: https://youtu.be/t9v0T6saH10
In this episode of the Mob Mentality Show, we dive into software development and team dynamics with Mark Shead. Discover how to revolutionize your team's productivity and create a more enjoyable work environment.
Leveling Up the Entire Team
- Maximizing Software Investment & Fun: Learn how mob programming boosts software investment value and enjoyment.
- Team Size Strategies: Debate whether to tackle problems with large teams or start with just 5 people.
- Real-Life Transformation: Hear the story of five individuals transitioning from solo work to pair/mob programming and the positive outcomes including reduced cycle times, enhanced delivery rates, knowledge sharing, and collective code ownership.
- Overcoming Silos: Address the challenge of tying self-worth to personal knowledge silos and the sunk cost fallacy.
- Bottleneck Resolution: Compare R&D bottleneck resolution in solo, isolated pair/mob, and dynamic pair/mob setups.
- Team Health: Learn why the speed of asking questions and seeking help is crucial for team health.
- Risk and Virtue: Discuss taking risks from a firm foundation and acting virtuously in a team, regardless of consequences.
- Sponsoring Risk Takers: Discover the importance of sponsoring and encouraging team members who take risks and ask questions.
- Learning Vulnerability: Hear Austin's baseball coach story on vulnerability and its relevance to software teams.
Effective Remote Teams
- Solo Work vs. Collaboration: Examine the norm of solo work and scheduled meetings leading to eight-hour days filled with meetings.
- Booking Meetings: Understand the inefficiency of booking meetings weeks in advance just to get necessary information.
- Remote Team Room: Learn about the remote team room approach that reduces cycle time for information sharing and fosters real-time collaboration.
- Video Call Dynamics: Address the fear of being on video and the impact of informal versus formal video styles on zoom fatigue.
BDD & TDD: The State of Software Development
- Roman Bridges Legend: Reflect on the "hopefulness" in the software industry and the parallels with the legend of Roman bridges.
- Known vs. Unknown: Delve into what is known versus unknown in software development.
- BDD/TDD Practices: Discuss how much BDD/TDD should be integrated with the UI and the fear of creating test code that might need changes later.
- Evolving Product Code: Become comfortable with evolving both product and test code.
- Coupling Tests to Design: Debate whether to couple tests to design or not, comparing London versus Detroit approaches.
- Unmatched Confidence: Discover the confidence boost that comes with well-executed BDD/TDD.
- Safe R&D Spaces: Balance the need for a safe time-boxed R&D experimental code with the certainty of test-driven development.
- Humoring the Coach: Hear anecdotes about teams humoring their coaches with TDD, only to embrace it enthusiastically the next day.
Don't miss this insightful episode filled with practical tips, real-life stories, and advice on enhancing your team's performance and software development practices. Tune in now to level up your team with Mark Shead!
FYI: Video and show notes to be posted here in the next day or so.
In this episode of the Mob Mentality Show, we are thrilled to have Diana Larsen, a leader in agility and team dynamics, join us for an in-depth conversation. Together, we explore the transformative power of mobbing, micro-retrospectives, and just-in-time learning for agile teams.
Micro-Retros:
- Discover how mobbing enhances the effectiveness of retrospectives.
- Address common complaints about retrospectives, such as time consumption.
- Learn how to integrate retrospectives seamlessly into the workflow.
- Understand the benefits of starting small, learning frequently, and continuously improving.
- Find the right cadence for short retrospectives, like using Pomodoro techniques or end-of-session reviews.
- Debate the necessity of including all five steps of a retrospective in a mini-retro.
- Explore the compound benefits of consistently "turning up the good" and building team confidence.
- Compare immediate actions in mini-retros to the traditional retrospective action items.
- See how natural, on-the-fly mini-retros can respond effectively to events.
- Discuss the role and timing of scheduled umbrella retrospectives.
- Examine system-level umbrella retrospectives, such as using Wardley Mapping for IT teams.
- Explore the dynamics of inter-team umbrella retrospectives.
Just-in-Time Learning:
- Harness the power of just-in-time learning through mini-retros.
- Learn how to embed learning into the work process rather than treating it as a separate activity.
- Understand the importance of not delaying learning when it’s most needed.
- Build co-intelligence within your team.
- Discover the immediate value of applying new knowledge.
- Learn strategies for quickly scanning books to set the stage for later just-in-time application.
- Discuss the value of knowledge that always applies and different types of knowledge.
- Navigate known unknowns and unknown unknowns in learning.
- Embrace a growth mindset and turn "I don't know" into a starting point rather than a barrier.
- Contrast the roles of software journalists versus software engineers in team learning.
New Ways of Working and the Future of Work:
- Debate whether Agile is becoming fragile and outdated.
- Explore the diffusion of Agile innovation with its pioneers.
- Learn creative approaches to high-collaboration, creative work.
- Looking ahead to new methodologies like Beyond Budgeting, Systems Thinking, and Wardley Mapping.
- Discover the continuous improvement efforts of leading Agile practitioners.
- Revisit Agile principles and values to compare and contrast with new movements.
- Respond effectively to emerging movements in the Agile space.
- Accept the limits of learning everything and seek insights from thought leaders.
- Witness the birth of new movements and predict the next thought leaders in Agile.
Diana's New Books:
- Dive into the 2nd Edition of "The Agile Retrospectives Book" which has just been released.
- Understand how this book serves as a catalyst for team learning and improvements.
- Discover the significant changes and updates since the first edition, including a section on remote retrospectives.
- Explore the meticulous re-analysis and updates made to every sentence and word in the book.
- Learn about Diana’s personal epiphany in her book "Lead Without Blame" and its focus on leadership, environments, and team responsiveness.
Diana's Upcoming Talks and Work:
- Get a preview of Diana’s upcoming talks at the Agile World Conference and the XP Conference.
- Learn about her participation in LinkedIn Live Events and the Agile Coaching Network as a panelist.
- Gain insights into her ongoing efforts in coaching leaders and influencing the Agile community.
Join us for this insightful episode filled with practical tips, expert advice, and forward-thinking strategies to enhance your team’s Agile practices and continuous improvement journey. Don’t forget to like, subscribe, and share to stay updated with the latest from the Mob Mentality Show!
Video and Show Notes: https://youtu.be/ONrfef1nkwc
Welcome to another episode of the Mob Mentality Show! In this episode, we dig into the essential 7th Habit of Highly Effective People: "Sharpen the Saw." Join us as we explore the concept's vital role in Mob Programming.
In This Episode, We Discuss:
- The significance of "Sharpen the Saw" in the Genesis of Mob Programming with Woody Zuill.
- The repercussions of neglecting to "Sharpen the Saw" and its impact on team efficiency and personal growth.
- Strategies for integrating "Sharpen the Saw" into your workday versus outside of work hours.
- The importance of dedicated learning time for continuous improvement.
- Comparing ad-hoc and scheduled approaches to sharpening the saw.
- Using learning sessions to enhance team skill diversity and foster a culture of growth.
- When to use kanban cards for "sharpen the saw" activities
- Creating a well-ordered life with scheduled habits for consistent personal and professional development.
- Insights from "The Power of Habit" and "Atomic Habits" on stacking habits for maximum impact.
- Transforming real knowledge and belief into action through proper identity and motivations.
Tune in to discover practical tips and strategies to keep your team sharp, focused, and continuously improving. Whether you're a seasoned mobber or new to the practice, this episode offers valuable takeaways to enhance your team's productivity and collaboration.
Don't miss this dive into the 7th Habit!
Join the Conversation:
Share your thoughts and experiences with us in the comments! How do you incorporate "Sharpen the Saw" in your daily routine? Let’s learn and grow together!
FYI: Video and show notes to be posted here in the next day or so.
Welcome to another insightful episode of The Mob Mentality Show! 🚀 In this episode, we dive deep into the 6th Habit of Highly Effective Mobbers: Synergize. Join us as we unravel the true essence of synergy and dispel common misconceptions portrayed in pop culture.
📚 What We Discuss:
- Synergy Defined: We explore the book definition of synergize and clear up misunderstandings surrounding the concept.
- Power of Collaboration: Discover how collaboration amplifies outcomes and why valuing people’s differences is crucial.
- Combining Strengths: Learn the art of leveraging diverse strengths to create powerful results.
- Mathematical Analogies: Understand when 1 + 1 equals 2.5, and why sometimes 1 + 1 can equal 1 or even -5.
- Third Alternative Creation: Find out how to create innovative solutions that go beyond compromise.
- Listening to Understand: Master the skill of active listening to foster better communication.
- Openness to Feedback: Embrace feedback with an open mind to enhance personal and team growth.
- Trust and Respect: See how a self-reinforcing feedback loop of trust and respect can elevate team dynamics.
- Improv Techniques: Utilize "yes, and" and perfect comedic timing to boost creativity and problem-solving.
- Safe Experimentation: Learn to make each person's experiment fast, safe, and a valuable learning experience.
- Embracing Failure: Cultivate an environment where being wrong and failing is part of the journey to success.
🔍 Why Listen?
- Enhance your teamwork skills by learning how to synergize effectively.
- Transform your approach to collaboration and problem-solving.
- Gain practical tips for building a culture of trust and continuous improvement.
Join us for a transformative discussion that will elevate your mobbing practices and help you become a more effective team player.
🔔 Don't forget to subscribe to The Mob Mentality Show for more episodes on mastering the habits of highly effective mobbers!
Tune in now and start synergizing like never before! 🎧
FYI: Video and show notes to be posted here in the next day or so.
Welcome to another episode of the Mob Mentality Show, where we jump into the dynamics of teamwork, leadership, and trust in the ever-evolving landscape of software development. In this episode, titled "Cultivating Trust and Influential Relationships with Leadership," we embark on a journey to decode the intricate nuances of fostering trust and building influential relationships with leadership.
Join us as we explore a myriad of topics, including techniques for influencing leadership within mobbing environments and navigating the complexities of both positive and challenged relationships with leadership figures.
We delve into the importance of inviting criticism and feedback, advocating for self-organizing teams, and navigating instances where leaders' actions diverge from their words. Is the "Good cop, bad cop" relationship dynamic a pattern or an anti-pattern?
Throughout the episode, we emphasize the significance of relentless transparency, genuine curiosity, and vulnerability in fostering natural trust and rapport. From leveraging the natural side effects of Mob TDD/CD to addressing chasms in relationship maps, come join our quest to unravel the secrets of effective trust-building interactions with leadership.
Tune in now to discover with us how to navigate the delicate balance between being at peace with your efforts and continuously striving for improvement while embarking on a journey towards unlocking the true potential of influential relationships in leadership.
Video and Show Notes: https://youtu.be/PQpp7S82TLc
Join us for a riveting episode of Mob Mentality Show as we delve into the dynamic world of cross-discipline "Aussie Agile" with Victor Agung and Jordan Ocokoljic. From their diverse experiences in Agile/XP, predominantly through pair programming, to insightful stories of mobbing, this episode promises to be an enlightening journey for Agile enthusiasts and novices alike.
In our conversation, Jordan shares his journey through various XP/pair shops, while Victor recounts his initiation into pairing and XP methodologies during his time at Pivotal. They discuss the transformative power of pairing, making mistakes a comfortable part of the learning process, and the shift from traditional code reviews to more efficient collaboration models.
Delving deeper, we explore the nuances of true collaboration as co-creation versus post-creation review, the benefits of pairing with cross-functional teams, and the paradigm shift towards continuous PR. Victor and Jordan share anecdotes of pairing with designers, business stakeholders, and PMs, highlighting the synergy achieved through collective intelligence.
Transitioning to stories of mobbing, our guests unravel the impact of collaborative mob sessions on team dynamics, skill development, and product outcomes. From UI/UX designers joining pairs to create a collaborative ensemble, to the invaluable lessons learned from seeking diverse opinions within a mob, every narrative underscores the power of collective problem-solving and empathy-driven collaboration.
Throughout the episode, Victor and Jordan emphasize the importance of promoting outcomes over practices, seeking the minimum viable number of useful opinions, orienting collaboration towards customer delight, and fostering a culture of humility and courage within teams. Their insights into unlocking the full potential of every team member's brain, and the role of mob/pairing as a supportive sounding board, offer actionable strategies for building resilient and high-performing Agile teams.
Tune in to "Agile Tales From Down Under" for an excursion in agile collaboration, filled with practical wisdom, heartfelt anecdotes, and transformative insights from two passionate practitioners.
Video and Show Notes: https://youtu.be/8jdps1V9vZY
In this engaging episode of the Mob Mentality Show, we delve into the intricate world of developer psychology and strategies for fostering a collaborative, innovative environment. Join us as we explore the challenges of influencing developers, from overcoming aversions to learning and change to embracing the skeptic within the team.
We address the pressing questions surrounding mobbing, including whether some changes, like transitioning to mobbing, are too monumental to tackle all at once. Join the conversation on whether starting with pair or mob programming is the easier path for your team's transformation.
Learn about the power of code reading clubs as a tool for continuous learning and improvement, and uncover techniques for fostering incremental learning to achieve the precise but powerful "fluent edge" in your development practices.
Throughout the discussion, we emphasize the importance of cultivating kind, warm discussions where objections are welcomed as opportunities for growth. We provide practical advice for creating a safe space for no-pressure experimentation, allowing your team to thrive and innovate without fear of failure.
Drawing from principles such as the 7 Habits and the pursuit of classical virtues of goodness, truth, and beauty, we offer some actionable strategies for focusing on what you can control and harnessing the full improvement potential of your developer team.
Tune in to gain invaluable insights and actionable tips for navigating the complex landscape of developer aversions and fostering a culture of learning, change, and influence within your organization.
Video and Show Notes: https://youtu.be/S1aAob44AzU
Welcome to another exciting episode of the Mob Mentality Show! Join us as we delve into the nuanced art of influence in our dynamic discussion titled "Building Bridges: The Art of Influencing Through Real Relationships and Excellent Environments."
In this episode, we confront the age-old question: Does persuasion via logic lead to backfire? We dissect this notion while exploring the effectiveness of environment strategies in the realm of influence. But hold on, is influencing via environment inherently sneaky or malicious?
We uncover the peril of the status quo and interrogate whether any room exists in a system for any incremental change. Reflecting on impactful literature like "Switch," "Made to Change," and "Power of Habit," we draw parallels to real-world scenarios and discuss their implications.
Navigating the landscape of relationships, our conversation explores the essence of connection and team building. Drawing from the metaphor of building bridges, we dissect the concept of natural influence versus calculated scheming, revealing the power of authentic connections.
Lastly, is there any danger of "successful influence" for bad reasons or from bad causes? Our candid discussion sheds light on the dangers lurking beneath the surface.
Tune in to discover actionable insights, thought-provoking perspectives, and strategies for leveraging influence ethically and effectively. Don't miss out on this episode of the Mob Mentality Show!
Subscribe now to stay updated on our latest episodes and join the conversation on our social media platforms. Let's embark on this journey together as we unlock the insights to real and lasting influence and impact.
Video and Show Notes: https://youtu.be/J9h7mEUBRZU
Embark on a journey into the world of collaborative learning with Yuki Tagawa and Christopher Martin as they unveil the "Mob Programming Tutor." In this episode, we explore the genesis of this cutting-edge tool, born from their university master's thesis work. Discover how it integrates a Mob Pomodoro Timer with an intelligent tutoring system driven by machine learning, to help improve the way students collaborate.
Join us as we dissect the intricacies of the tool's development, its unique features like auto-shifting break times and feedback on mob roles, and its potential to transform both learning and teaching paradigms. Learn firsthand from the creators about the tool's impact on student collaboration and its future trajectory.
But that's not all – we delve into the broader landscape of Mob Programming in education. Uncover the challenges of teaching collaboration, strategies to enhance educational philosophy, and the technical nuances that make this tool a transformative educational experience.
Tune in for insights, actionable tips, and a glimpse into the future of collaborative learning. Whether you're a student, educator, or industry professional, this episode aims to leave you enlightened and inspired.
Don't miss out – join the conversation today!
Video and Show Notes: https://youtu.be/3Rhnj7jZWl0
Dive deep into the realm of collaborative programming with a unique twist in this episode of Mob Mentality Show where in the spirit of "just sharing" Austin Chadwick unravels 20+ misconceptions and anti-patterns surrounding Mob Programming.
From debunking the myth of Mobbing as merely 3+ individuals watching one person type to exploring the misconception of Mobbing being inherently slow and tedious, we dissect various preconceived notions about this innovative approach to coding. At this recorded Agile Lunch and Learn event, explore with us as we challenge the belief that Mobbing is monotonous and that every session involves wooden inflexible navigation and team composition.
Moreover, we shed light on the diverse roles within a Mob, addressing the anti-patterns that can hinder effective collaboration. Meet the Anti-Driver, the Anti-Navigator, the Anti-Nose and other personas that disrupt the harmony of Mob Programming. Discover how collaboration can falter under the influence of Fight Club dynamics, lack of prioritization, and lack of pressure protection.
At the end of this episode, we invite you to engage in a thought-provoking Q&A session, where we tackle burning questions about Mob Programming. Don't miss out on this opportunity to redefine your understanding of Mob Programming and revolutionize your approach to collaborative coding.
Tune in now to Mob Mentality Show and embark on a journey towards a deeper comprehension of Mob Programming – what it truly is not.
Video and Show Notes: https://youtu.be/Z5x5nYXBpis
In this compelling episode of the Mob Mentality Show, prepare to be immersed into the dynamic world of Computer Science (CS) education with none other than Kieran Murphy, who is not only a seasoned tech consultant but also a university CS instructor. This episode offers an exclusive peek into Kieran's journey and the profound implications of mob programming in the undergraduate CS classroom.
Throughout the episode, Kieran shares invaluable insights gleaned from his experiences, including the pros and cons of live coding sessions, the rationale behind integrating mob programming into the curriculum, and the tangible effects witnessed on students and on course structure and assignments. Delve into the nitty-gritty as we explore strategies for kick-starting code projects, navigating the dynamics of class sizes, and fostering effective communication and collaboration within the course.
Moreover, gain firsthand knowledge on facilitating constructive feedback exchanges among students, managing remote participation, and anchoring engaging mob sessions in virtual environments. From mini-retrospectives to timer rotations, no stone is left unturned as Kieran elucidates many intricacies of mob programming implementation in a computer science class.
But that's not all—tune in to discover the candid feedback received from students, as well as the invaluable lessons learned from this innovative approach to teaching. Whether it's embracing diverse learning styles, navigating IDE strategies, or instilling a growth mindset in budding coders, Kieran's expertise offers actionable insights for educators and learners alike.
So, whether you're a seasoned educator, aspiring developer, or simply curious about the future of CS education, this episode promises to inform, inspire, and spark meaningful dialogue. Don't miss out on this illuminating exploration of mob programming's role in shaping the next generation of tech talent!
Video and Show Notes: https://youtu.be/jtQ-Yeyowg4
Welcome to another enlightening episode of the Mob Mentality Show! In this episode, we delve deep into the dynamic world of software architecture and the transformative power of collaborative programming with the insightful Allan Stewart.
As a seasoned architect, Allan brings a wealth of experience to the table, shedding light on how mob programming influences architectural decisions and vice versa. Join us as we explore the nuances of architecture consistency, the impact of clean architecture on adaptability, and the vital role of communication and systems thinking in driving business results.
But that's not all! Allan takes us on a journey beyond traditional architectural roles, discussing the emergence of the collaborative architect within mob programming environments. Discover how one version of this role navigates multiple mobs, fosters cross-pollination of ideas, and champions humility in architectural decision-making.
Transitioning into the realm of technical lifestyle changes, Allan shares invaluable insights on bridging the gap between tech goals and real-world implementation. Going beyond "the waving of the magic wand of transformation" and instead kick-starting actual continuous improvement initiatives, Allan offers practical strategies for cultivating a culture of excellence within tech teams.
We also delve into the fascinating intersection of sociotechnical patterns and the challenges of overcoming apathy and resistance to change. Allan's "go-to" techniques for lifestyle technical coaching provides experiments for teams seeking long-term wins noticed by the business.
Finally, we explore mobbing contexts, from its applicability in startup environments to its impact on uncertainty and interdependence. Allan's firsthand experiences and thought-provoking insights shed light on the true essence of mob programming, its potential to revolutionize software design, and discovering the contexts for when it is effective and the contexts for when it is not effective.
So, whether you're a seasoned architect seeking fresh perspectives or a tech enthusiast embarking on a journey of transformation, this episode is packed with actionable insights to elevate your game. Tune in now and join the conversation with Allan Stewart!
Video and Show Notes: https://youtu.be/C2a1qBF6jtE
Welcome to a groundbreaking episode of the Mob Mentality Show, where worlds collide in a crossover event with Luca Ingianni & Jeff Gable from The Agile Embedded Podcast. Joining us as they delve deep into the intricacies of the embedded systems industry from a teaming/mobbing perspective.
In the first part of the discussion, industry veterans Jeff and Luca share their insights into the "Pain Points and Practices of the Embedded Systems Industry." They explore the challenges of code coupled to hardware and discuss strategies for breaking down isolated silos. Can Electrical Engineers, Mechanical Engineers, and Firmware Engineers all work well together? How has the industry coped with post-COVID supply chain issues, and is the traditional yearly release cycle still viable?
Key Highlights:
- Code decoupling strategies
- Adapting to post-COVID challenges
- Breaking down industry silos
- Cross-discipline team formation
In the second part of the discussion, Chris and Austin provide an "Intro to Mob Programming from an Embedded Systems Perspective." Uncover the dynamics of collaboration with firmware engineers, the power of ad-hoc mobbing, and the benefits of problem-solving together in real-time. Learn about the growth of mobbing, from "destroying silos" to "just sharing" and "coalition of the willing." The hosts explore sizing mobs/teams for large cross-functional IOT teams, live code reviews, and the application of Conway's Law.
Key Highlights:
- Collaborative problem-solving
- Mobbing for less coupling
- Sizing mobs for large teams
- Applying Conway's Law and Inverse Conway Maneuver
Join us on this journey of exploration and transformation, covering topics from safety-critical processes to clean architecture. Unleash the potential of Mob Programming in the embedded systems domain and discover new avenues for collaboration, innovation, and continuous improvement.
Tune in for a paradigm-shifting episode that will inspire, inform, and propel your understanding of teamwork and agility in the embedded systems industry. Don't miss out on this unique collaboration between Mob Mentality Show and The Agile Embedded Podcast!
Video and Show Notes: https://youtu.be/3D8TBaVQup8
🎙️ In this episode of Mob Mentality Show, we dive deep into the realms of continuous global mobbing sessions and the art of refactoring to services with the dynamic Skylar Watson. Brace yourself for an eye-opening conversation that explores the unprecedented challenges and triumphs of leading teams across multiple continents, all while optimizing effectiveness and fostering a global culture of collaboration.
🚀 Continuous Global Mobbing Sessions
🌍 Skylar takes us on a journey through his experiences in helping to orchestrate global mobbing sessions, where teams seamlessly transitioned their operations to the cloud. From the initiation of pair/mob coaching to running 24x5 mob sessions across different time zones, Skylar unveils the intricacies of managing overlapping periods and passing the development story baton from one continent to the next.
🕰️ Discover the impact on cycle time and throughput, and unravel the team dynamics when faced with the challenge of context passing. What were the initial reactions? How did team ownership versus individual contribution play out? Find out the surprising results and the lessons learned from this groundbreaking experiment.
🔄 Mobbing Full-Time and Chats with VPs: Revolutionizing Work Prioritization
💡 Skylar shares insights on how full-time mobbing can be a stress-relief prescription for development teams, transforming the chaos of multiple priorities into a streamlined, focused approach. Learn how the shift from "everything is #1 priority" to a singular #1 priority improved efficiency and sparked collaboration. Delve into the challenges faced when handling objections to mobbing, and explore the transformative power of mobbing as a problem-solving mechanism.
📈 Skylar's fascinating journey includes encounters with VPs and questioning traditional productivity norms. Hear the thrilling account of a Twitter post leading to a VP discussion on mobbing, and how the Mob experiment unfolded in a transparent "glass house" setting.
📚 Skylar's Book on Refactoring to Services: Unlocking the Secrets of Microservices
🛠️ Transitioning from mobbing to Skylar's expertise in refactoring, we explore his book on refactoring to services. Skylar provides valuable insights into extracting microservices from a monolith, discussing the nuances of branching versus Trunk Based Development (TBD). Gain practical knowledge through concrete examples, and unravel the mysteries of keeping changes small with inside-out versus outside-in refactoring.
📖 Dive into Skylar's evening projects, where he hones his skills and tests hypotheses. Discover the impact of Trunk Based Development on git skills and the art of "forgetting well." Skylar also gives us a teaser on his upcoming book on data empowerment.
🚀 Don't miss out on this episode as Skylar Watson takes us through the highs and lows of continuous global mobbing and the intricate process of refactoring to services. Tune in now for an immersive experience in the world of mob transformation!
Video and Show Notes: https://youtu.be/KUp6xE5Hy7c
Welcome to another exciting episode of the Mob Mentality Show! In this edition, our guest, the remarkable John Gallagher, takes us on a journey through the intricate world of software design, focusing on the compelling theme - "Reducing Cost of Change Through Design."
🛠️ Episode Highlights:
- John's Code Mentoring Journey: Gain insights into John's remarkable journey of being mentored through the realms of code encapsulation, TDD, and the ripple effects from code changes.
-
Abstraction and Coupling: Explore John's insights into the nuanced interplay of coupling and abstraction in software design. Discover how these principles contribute to the ultimate goal - Reducing the Cost of Change.
-
Software Design Simplified: Delve into John's book, "Software Design Simplified," as he shares its origin story and how it addresses what is missing in many software design books.
-
Domain Modeling in Rails + Mobbing/Pairing: Shift gears to the fascinating world of domain modeling in Rails with stakeholders from the business present daily. Understand the art of mapping domain to code using whiteboards, index cards, and magnets. Learn the secrets of better design through the powerful combination of tools, focus, and collaborative efforts within pair/mob programming scenarios. Experience the joy of kneading code like dough as John reveals his dream way of working - Domain-Driven Design paired with pair/mob programming.
-
Joyful Programming Inspired by Unison: Embark on a visionary exploration of joyful programming inspired by Unison. Discover a truly unique programming language that re-invents everything including code with no builds and no files on disk.
🚀 Tune in now for an episode packed with wisdom, humor, and a wealth of practical knowledge for software enthusiasts!
Video and show notes: https://youtu.be/33rOocC2yBs
In this new episode come join the conversation that includes a fascinating blend of collaborative techniques and creative processes utilized in the development of games and fiction, highlighting the use of tools like Lean Coffee, Trello, Asana, and Notion to facilitate world building, mobbing, and game design. Chris Lucian, along with emergency co-host Luis Martinez, discusses with guests Emily Earhart and William Munn their unique approach to creating immersive game experiences and the seamless integration of agile/mob methodologies into creative endeavors.
Emily and William share insights into their tarot card RPG project, illustrating how collaborative analog design processes can yield innovative and engaging content. They emphasize the use of Lean Coffee to generate ideas and build consensus among team members, creating worlds that are diverse, unique, and compelling. The conversation also delves into the importance of making work visible, the joy of seeing progress through completed tasks, and the psychological benefits of organizing and visualizing work, whether in a professional setting or personal projects.
The discussion further explores how these collaborative and organizational strategies not only enhance productivity and creativity but also foster a supportive and inclusive environment for team members to contribute and refine ideas. The guests also touch upon the challenges and rewards of working collaboratively, the process of resolving conflicts, and the adaptability of these methodologies across different contexts, from game design to personal organization and beyond.
Emily and William's experiences underscore the fluidity between work and play, demonstrating that the principles of lean management and agile methodologies can be effectively applied to creative processes, enhancing both efficiency and enjoyment. Tune in to be inspired by their models of collaboration, communication, and organization and how it can transform the way we approach creative endeavors, making them more engaging, inclusive, and effective.
Video and Show Notes: https://youtu.be/94DeuBfwxDk
Dive into the world of startups, burnout, and the alchemy of building antifragile teams with Jesse Riley on this episode of the Mob Mentality Show! Unpack mobbing/pairing in startups and small companies, where knowledge spreading and the bus factor is a game-changer. Discover how avoiding the knowledge bottleneck of one person can help your startup thrive undue pressure.
Explore the critical role of vacations in startups, the impact of stressed-out devs, and the art of hiring developer zero. Learn the significance of errors/bugs in a startup and why startups are somewhat analogous to safety-critical systems. Join us as we unravel the mysteries of feedback loops, integration needs, and unit testing in the startup ecosystem.
Discover how Lean/XP developers provide a competitive advantage for an org, seamlessly sliding into any team like a well-trained Navy Seal. Unearth the insightful Kanban/no-estimates story where "all stories are 1s" and weigh-in on the solution to the inverse semantic diffusion problem.
As we reflect on nearly two decades of Agile, question its future, and ponder if it's over, we explore the Agile Industrial Complex and distinguish between the marketing term and the true philosophy. Is "Agile" in need of improvement, or are we entering a new era of iterative practices?
Cap off the episode by delving into the art of mentoring new devs and CTOs alike. Gain insights into guiding the next generation in the ever-evolving landscape of software development.
Tune in for a riveting conversation that unveils the magic of mobbing, the resilience of antifragile teams, and the secrets to sustaining success in the startup ecosystem. Subscribe now for your weekly dose of wisdom and actionable insights.
Video and show notes: https://youtu.be/LCXbrmwbTX4
Join us for an insightful conversation with Philip Markgraf on how Mobbing serves as the keystone of the third generation of XP, pushing the boundaries of innovation, evolution, and continuous improvement.
In this episode, we explore:
-
The Evolution of XP Practices in Phil's Mobs
-
Dive into the nuances of "full mob" adoption and its implications for team dynamics.
- Discover simple definitions that unveil the deeper richness of mobbing.
- Is mobbing synonymous with "all the good things," or, is it simply "all the brilliant minds working on the same thing, at the same time, in the same space, on the same computer"?
- Explore the importance of a good player/coach in fostering effective mobbing.
- Contrast building a mob team from scratch with introducing mob Test-Driven Development (TDD) to existing teams.
-
Is good mobbing the cornerstone to all else? Or, is it TDD? Or, is it The Virtuous Loop?
-
Mobbing in Safety-Critical and High-Reliability Software
-
Understand the rationale behind TDD mobbing in safety-critical systems.
- Delve into the challenges of achieving zero bugs in medical and safety-critical environments.
-
Uncover ways to address the issue of flakey end-to-end tests in critical systems.
-
Lightweight Methodologies for Regulated Industries
-
Follow Phil's journey from embedded systems to mob programming.
- Gain insights into applying XP in Embedded and IoT development.
-
Explore mobbing experiments in electrical engineering, mechanical engineering, firmware, and software.
-
Solo Programming After 20 Years of Mobbing
-
Navigate the challenges of solo programming after years of pairing and mobbing.
- Tackle loneliness and loss of motivation in the absence of collaborative programming.
- Discover strategies for playing the Mob RPG alone and staying motivated.
Tune in for a captivating discussion that transcends traditional programming methodologies!
Video and Show Notes: https://youtu.be/Y4aHoiKh2XA
Dive into the world of zero bugs and lean mobbing with David Batten on this episode of Mob Mentality Show. Discover the distinction between the scary and healthy versions of zero bugs, and explore how David and his teams achieved a bug-free environment. Uncover insights on when to shift focus away from zero bugs, anti-patterns to avoid, and the art of baking quality into your code.
Explore the synergy of Lean principles, Continuous Delivery (CD), and Test Driven Development (TDD) as David shares how they got to zero bugs as a natural side effect. Learn about the application of the prime directive to foster continuous improvement and the joy of being in a bug-free system.
Explore the facet of Lean where we draw systems and seek ways to shorten feedback loops. Gain insights into the business perspective on Lean and the power of tiny commits. Understand the role of Lean in risk conversion, frequency, and Domain Driven Design (DDD) for organizational simplicity.
Join us in exploring the art of mobbing as David recounts his first mobbing experience to meet a deadline and shares his 9 years of mobbing wisdom. Learn how having the entire system in the room ensures that when it's done, it's truly done. David also discusses the impact of mobbing on CD, the benefits of bringing the best of everyone into the code, and a sneak peek into the April 2024 Teaming Conference.
If you're passionate about #mobprogramming, #bugszero, #continuousdelivery, #tdd, #leanthinking, #xp, this episode is a must-listen. Elevate your coding mindset and join the conversation on achieving zero bugs naturally through lean mobbing!
Video and Show Notes: https://youtu.be/8-EL9x89Ag0
Come hear the story of a thriving team dynamic in this episode of Mob Mentality Show with special guest Robin van den Bogaard! Join us as we delve into the journey of Robin's team experimenting with mobbing, transforming their approach from Scrum to pair to mob collaboration.
In discussion, we explore the pros and cons of the mobbing experiment, from the initial skepticism of Product Owners to management's response. Discover what it is like to be in a system where no need to ask to mob... just do it!
Gain insights into the organizational and Product Owner perspective shift on the teams' ability to deliver and the remarkable impact of mobbing on domain knowledge sharing. Learn about the likelihood of painting yourself into a corner in a mob versus going solo, and the integration of Kanban, flow, and Scrum, along with the intricacies of working with Jira and estimates while mobbing.
Explore the transformative effects of mobbing on team communication, sensitivity to tension, and addressing the elephant in the room. Uncover the strategies for mining for conflict early in the mob and creating an environment where teams can "say anything" to each other.
Also join us as we discuss how mobbing led to the opening of new doors, enabling team members to give talks internally and externally. Revel in the fun experiences of being the first person to introduce mobbing to someone.
Whether you're interested in mini-daily retrospectives, improving design and scouting in micro-services with ports and adapters, or navigating the challenges of too much low-level navigation in a mob, this episode covers it all. In addition, hear about the horror story of an old repo becoming unbuildable, the new pattern of staying radically up to date every day, and the impact to security.
Tune in to Mob Mentality Show today and discover the transformative power of mobbing with Robin van den Bogaard, where joy, collaboration, and innovation intersected in his ensemble to create a dynamic and effective team culture!
Video and Show Notes: https://youtu.be/9vUyLOLQtzQ
🚀 Dive deep into the world of Pair Programming with Gabriel Robaina and Kieran Murphy as they unravel how to tune this "Sensible Default Practice" into even more of a game-changer! 💻✨
In this episode, our discussion covers crucial aspects of pair programming that go beyond the basics. Are your pairing sessions dragging on for too long? Do you notice anti-patterns similar to solo programming? Learn how to identify and address these issues with Gabriel and Kieran's insights.
Explore the journey that led their team to embrace pair rotations and the valuable lessons learned along the way. Is pairing valuable but challenging? Uncover strategies to make it work for your team and turn challenges into opportunities.
🔍 Key Highlights:
- Observing and responding to low engagement during planning
- Breaking down knowledge silos within a pair
- The "hurt so do it more" philosophy: Does it really work?
- Implementing the Pairing Pomodoro technique
- Pair switching logistics: within a team vs. between teams
- Overcoming resistance to pair switching
- Ensuring bug fixes by anyone on the team through collaborative efforts
- Maintaining context with pair rotations via minimum viable anchoring
- Distinguishing between anchor role and champion role in pair swapping
- Logistics of pair rotations: open-ended self-organized vs. planned in detail
- Mob swaps: dice rolls and "wheels of doom" 😅
- Story slicing techniques conducive to pair rotations
- Using Mural boards for pair and work context
- Long-running retro boards: What's hard vs. easy with pairing
- Building strong team connections through pair swaps
- Incorporating feedback practices within pairs
Also, stay tuned for an exciting teaser on "Mob Programming in a Computer Science Classroom Setting" that will leave you eager for more collaborative insights!
Watch now for a dose of practical wisdom that will impact your approach to collaborative coding. 🎙️✨
Video and Show Notes: https://youtu.be/aurVZM6ZTUw
Dive into the intricate world of innovation diffusion on this episode of the Mob Mentality Show. Join us as we dissect the dynamics between healthy and destructive speeds in team switching, exploring the nuances that shape team cultures and impact the quality of outcomes.
🚀 Episode Highlights:
Navigating the Pace of Innovation: Engage in a thought-provoking discussion on the healthy and destructive facets of innovation diffusion. Explore the repercussions of fast and slow diffusion, addressing critical questions like whether innovation can happen too swiftly, causing semantic diffusion, or if it can be hindered by insulated innovators.
Balancing Act: Culture and Quality: Delve into the delicate balance between preserving organizational culture and ensuring the quality of innovations. Uncover strategies for fostering a culture that encourages experimentation while upholding high standards.
Coaching Dynamics: Explore the dynamics of short-term versus long-term coaching, dissecting how coaching durations impact team growth. Learn actionable insights on how to effectively nurture and grow collaborative mobs.
Team Switching Strategies: Unpack the challenges of dynamic reteaming and team switching, investigating whether excessive switching can lead to problems or if inadequate switching stifles the spread of positive changes. Discover the intricacies of promiscuous pairing/mobbing and the Two Team Linking Navigator Pattern.
Preserving Lofty Goals: Join the debate on preserving the outcomes of ambitious goals amidst the dynamic landscape of team growth and innovation. Gain valuable insights into strategies that allow teams to maintain focus on their lofty aspirations.
Tune in for an exploration of the healthy and destructive speeds in the diffusion of innovation. Whether you're a seasoned professional or a curious learner, this episode helps you navigate the complexities of team dynamics and systems thinking. Don't miss the chance to enhance your understanding of effective collaboration and growth strategies in the ever-evolving world of software development! 🌐
Video and Show Notes: https://youtu.be/nDieux1ZqGs
Venture into the rich tapestry of professional programmer history with the prolific Uncle Bob Martin on this episode of the Mob Mentality Show.
🕰️ Episode Highlights:
Unveiling Programmer History: Join Uncle Bob as he unfolds the history of programmers, emphasizing their humanity beyond mere coding. Explore fascinating anecdotes about pioneers like Grace Hopper and Edsger Dijkstra, discovering the roots of code as it evolved from the manual computation era to the present.
Code Collaboration Through the Ages: Delve into collaboration patterns, uncovering the early instances of social programming.
The Quest for the Perfect Language: Journey through the landscape of programming languages, paradigm shifts, and the impact of TDD. Uncle Bob shares insights on the nuances of runtime vs. compile-time type checking and his personal odyssey into functional programming via Lisp and Clojure.
Impactful Professionalism: Explore the profound impact of programmer professionalism on society. Uncle Bob discusses the unprecedented world dependence on such a young software industry, emphasizing the importance of learning in safe spaces.
Tune in for an enlightening exploration of programmer history, language evolution, and the pivotal role of professionalism in shaping the technological landscape. Whether you're a seasoned developer or an aspiring programmer, this episode promises valuable insights into the roots and future of our coding journey. 🚀
Video and Show Notes: https://youtu.be/Pv_bzO95qqs
Dive into the intricacies of remote mob programming from the perspective of an introvert on this episode of the Mob Mentality Show with our guest, Chris Stone. Join us for a fascinating exploration of the benefits and challenges, seasoned with 2.5 years of Chris's mobbing experience.
🌟 Episode Highlights:
Unlocking the Introvert's Tale: Delve into the unique insights of an introvert's journey in collaborative coding. Chris Stone unravels the energy dynamics of mob programming, addressing the complexities of social coordination versus solo work and the nuances of giving feedback in a mob versus pull requests.
Remote Work: Beyond the Office Walls: Challenge the common notion that collaboration thrives only within office walls. Explore how remote mob programming becomes the key to maintaining programming jobs remotely and whether this strategy could be the cornerstone of the future of work.
Litmus Test for Collaboration: Is the willingness to mob a litmus test for qualities like empathy, humility, and honesty? Unpack the semantics of "Remote Work" and discover the contrasting experiences of team meetings versus the engaging world of mobbing.
Retrospectives and the Art of Experimentation: Chris Stone provides insights into using retrospectives as a powerful tool to foster authentic engagement and experimentation with skeptics within mob programming. Gain practical tips on structuring retros, facilitating them, and leveraging constraints for creative breakthroughs.
Tune in to gain a fresh perspective on remote mob programming, tailored for introverts. Whether you're an avid mob programmer or exploring collaborative coding, this episode offers valuable insights for all. Don't miss the chance to enhance your understanding of effective remote work and team collaboration! 🚀
Video and Show Notes: https://youtu.be/zDd6HnP9uUk
From an RV at a national park in the woods to the beaches of an ocean reef resort on the coast, Michael Wolf can be found finding joy in remote work and remote mob learning. Join us today on the Mob Mentality Show as he shares his unique experiences and insights.
🌐 Episode Highlights:
Foundation of New Teams with Mob Learning: Explore how Mob Learning serves as a robust foundation for the formation of new teams. Michael delves into the power of joining a mob to code, emphasizing the importance of embracing discomfort and learning through hands-on experiences.
Agile Coaching and Scrum Mastery: Discover the transformative impact of Mob Learning on agile coaching and scrum master skills where Michael advocates both being a coach and being coached.
Navigating Remote Mob Patterns: Uncover the nuances of remote mob patterns, breaking down barriers between "us" and "them." Michael explores the pros and cons of Mob Learning, offering practical tips to enhance the learning experience for participants.
Effective Collaboration Practices: From avoiding "stupid gas" to maintaining focus on bright spots, learn the keys to effective collaboration in a mob. Michael shares insights on creating a safe space for all levels of experience.
Michael's Weekly World Mobbing Tour: From the Mob RPG Ensemble to the ApprovalTests.Python Ensemble to Code Craft Saturday/Sunday, Michael shares his weekly experiences in the vibrant public mob community.
Tune in to discover the essence of Mob Learning and its transformative influence on teams, coaches, and individuals. This episode is a great listen for anyone seeking to harness the power of collaborative learning in the dynamic world of software development. 🚀
Video and show notes: https://youtu.be/XDOiV2J1pVo
Set out on a journey across continents in this episode of the Mob Mentality Show, where we explore the dynamic realm of remote cross-continent mob programming. Join our guests Jeff Langr, Nick Goede, and Merlijn Tishauser as they share stories and insights from their year-long collaboration on a front-end project.
🌐 Episode Highlights:
Navigating Time Zones: Explore the intricacies of establishing core working hours in a cross-continent ensemble. Uncover how the team managed flexibility and handled work outside of these core hours, featuring insights into maintaining a relaxed yet productive schedule.
Fluid Team Dynamics: Learn how the mob coped with the dynamic flow of people coming and going. Understand strategies for a more flexible and adaptable team/mob schedule, fostering a collaborative environment that thrives on change.
Optimal Mob Size: Join the discussion on the optimal mob size for maximum engagement and productivity. Delve into the impact of day-to-day variance in mob size, and discover how automation and various roles can contribute to efficient mobbing, especially when mobbing on "pixels."
Outsourced Mob Challenges: Understand the client collaboration patterns in an outsourced mob setting. Navigate the challenges of being a team without access to internal people/resources.
Remote vs. In-Person Collaboration: Compare the experiences of remote and in-person collaboration, examining the unique dynamics of XP mobs interacting with potentially non-agile stakeholders. Explore the joy of mobbing and building trust through seamless delivery despite system challenges.
Tune in for a compelling exploration of remote cross-continent mob programming and discover the delight that emerges amidst the complexities of global collaboration. Don't miss this episode packed with real-world experiences and insights from seasoned technical coaches! 🌍🚀
Video and Show Notes: https://youtu.be/6jI-VI8-TLU
Embark on an immersive exploration of Mob Programming in the Summer of Nix 2023 in this episode of the Mob Mentality Show. Joining us are participants Lorenz, Dawn, Valentin, Albert, and Auguste as they unravel the intricacies of this unique collaborative experience.
🚀 Episode Highlights:
Understanding Nix and the Summer of Nix Program
- Gain insights into the fundamentals of Nix and an introduction to the Summer of Nix program. Explore how ensemble programming is utilized to learn, collaborate, and tackle issues across a spectrum of technologies.
Mobbing to Learn: Navigating the Nix Community and NixOS Project
- Dive into the fascinating world of mob programming as a tool to efficiently onboard less experienced programmers. Discover how the Summer of Nix acts as a gateway to the Nix community and the expansive NixOS project.
Open Source Collaboration Challenges: From Visibility to Accessibility
- Uncover the general challenges faced in a program like Summer of Nix, focusing on making open source work more visible and accessible. Explore the redundancy and social commitment benefits of mobs when collectively working on impactful open-source projects.
A Ride through Summer of Nix: Past Editions vs. 2023
- Take a comparative journey through the previous editions of Summer of Nix and the unique aspects defining the 2023 edition. Learn about the dynamics of helping project authors get their work "taken for a ride" through collaborative efforts.
Tune in to this illuminating episode for an insider's perspective on the Summer of Nix 2023, where mob programming becomes a catalyst for knowledge-sharing, problem-solving, and fostering a vibrant open-source community. Don't miss out on the camaraderie and insights shared by our awesome panel. 🌟
Video and show notes: https://youtu.be/VnT5VxMFGAI
Dive into a thought-provoking episode of the Mob Mentality Show as we embark on a dispassionate tour of complexity, imprecision, and unprofessionalism with the insightful Seb Rose.
🎙️ Episode Highlights:
Beyond "Best Practices": Challenge the fallacy of "best practices" as Seb Rose unveils a pragmatic perspective on navigating the intricate world of software development. Explore the implications of the Cynefin Framework and learn the art of offering advice in a pattern format, promoting a culture of learning over dogmatic adherence.
Dispassionate Professionalism: Discover the difference between passion, professionalism, enthusiasm, and grit. Explore the realms of dispassionate professionalism, the allure of fast universal answers, and the power of vulnerability.
Sustainability & Agility: Join us as we reflect on the relation between sustainability, agile conferences, lean, computing, and remote mob programming.
Tune in for an enriching conversation that explores navigating complexity with a dispassionate yet engaged mindset. 🚀
Video and Show Notes: https://youtu.be/VfZfBDidNXE
Join us for an enlightening episode of the Mob Mentality Show as we delve into the fascinating realm of collaborating with AI. Our guest, David Bernstein, is the co-author of a new book on prompt engineering, and he's here to provide key insights into mastering the art of working with AI.
📚 Episode Highlights:
Prompt Engineering for Everyone: David introduces the concept of prompt engineering and highlights the universal applicability of this skill.
A Glimpse into David's New Book: Get a sneak peek into David's latest book, co-authored with AI 🤖. Learn how it can empower you to become a proficient collaborator with AI systems.
Unlocking AI Collaboration for All: Explore the scope of the book, covering prompt engineering from beginner to intermediate and advanced levels, making AI collaboration accessible to all.
Treating AI as a Human: David discusses the importance of approaching AI as if it were a human, enabling effective collaboration and communication.
Common Pitfalls and Challenges: David sheds light on common pitfalls to avoid when engaging with AI/LLM systems.
Exploring Prompt Nuances: Delve into the subtleties of prompt engineering techniques, encompassing both open-ended and close-ended prompts.
AI Collaboration Beyond Coding: David shares fascinating insights into using prompt engineering for diverse domains.
Thriving with AI: Discover how AI can be a valuable asset for software developers, aiding in prototyping and problem-solving.
Tune in for an illuminating discussion on the power of prompt engineering and effective collaboration with AI. Whether you're a coding enthusiast or simply curious about the future of AI, this episode will provide valuable insights into the AI landscape. Don't miss it! 🤖🎙️
Video and Show Notes: https://youtu.be/tYGRT4clt88
Join us for an expansive episode of the Mob Mentality Show as we jump into effective mob programming with a twist: facilitating as a less technical coach. We are joined by Nazee Hajebi as she brings this fresh perspective into the world of ensemble programming.
🎙️ Episode Highlights:
Starting the Mob Journey: Nazee shares her real-life experiences and insights into helping teams kickstart their mob programming journey.
Obstacles and Overcoming: Discover the common obstacles Nazee faced as a non-technical coach and learn her valuable tips for overcoming these challenges. Find out how to tackle the fear of other developers and the art of establishing an experimental mindset that encourages trying twice before saying "no forever."
Setting the Stage: Learn the crucial steps to set the stage effectively before diving into a mob programming session. Identify common anti-patterns and pitfalls of the first mob session and how to steer clear of them.
Why Non-Tech Coaches Mob: Understand the compelling reasons why non-technical scrum masters or coaches should try facilitating mobbing sessions. Explore the value of mobbing and whether it's a waste of time from a non-tech perspective. Compare a 2-week pull request process to all tasks completed in the same day with mobbing.
Domain First: Uncover the importance of helping the mob speak in plain language, demystifying complex technical jargon.
Vulnerability and Growth: Learn the power of demonstrating vulnerability and fostering a growth mindset within the mob. Delve into coaching anxiety in a mob and the deliberate purpose of each mob session. Discover the art of coaching not just on code but also on effective communication and collaboration.
Mentoring the Mentors: Nazee's insights into mentoring other non-tech coaches to facilitate mobs and lower the bar for what it takes to be a great mob coach.
Tech Allies and Tech Learning: The role of having a tech ally within the mob session and the when, why, and how of starting with simple problems like "fizz buzz." Learn the process of non-technical coaches learning tech as they facilitate mobs.
Tune in to gain unique insights into effective mob programming from a non-technical angle. This episode is a must-listen for anyone interested in fostering collaborative and productive teams, regardless of their technical background. Don't miss it! 🌟
Video and Show Notes: https://youtu.be/9OHBV9GSJJQ
Welcome to an adrenaline-pumping episode of The Mob Mentality Show! In this captivating installment, titled "Mastering the High Stakes Arena: A Story of Mobbing Under Pressure with Giovanni Asproni," we dive into the thrilling world of Mob Programming in high-pressure environments.
Join us as we embark on an exploration of high stakes work, dissecting the very definition of what "high stakes" truly means. Giovanni Asproni takes us on a roller-coaster ride through his enthralling story of Mob Programming under the intense pressure of a high-stakes scenario.
Discover the challenges and triumphs faced during those critical first moments with a new team amidst a high-stakes project. Giovanni provides insights into the diverse skill sets and experience levels within and outside the mob, shedding light on whether the decision to mob was driven by the high stakes or not.
Uncover the significance of bugs in high-stakes products, and the accessibility and security constraints in this specific situation. In the midst of high-stakes work, Giovanni emphasizes the unwavering commitment to quality, exemplified by full Test-Driven Development (TDD) and the art of story slicing.
Delve into the world of unorthodox design for observability and the dynamics of decision-making in high-pressure mob settings. Explore the rapid shift to radical candor while the pressure mounts and learn strategies for managing stress within the ensemble.
Giovanni shares his experiences of mobbing under pressure with unfamiliar team members, touching upon the role of a team/mob firewall/gatekeeper and the value of pairing during meetings. Gain insights into overcoming major challenges when mobbing versus working solo and the critical importance of the bus factor and resilience in high-stakes endeavors.
Unearth the secrets behind maintaining high automation levels and Giovanni's epic 16-hour mobbing marathon learning Terraform. Discover the nuanced approach to TDD within the mob while having manual testing support outside of it.
And yes, we even explore the surreal scenario of having a prime minister as a major stakeholder - you won't want to miss that story! Join us as we discuss their race against time to deliver and authentically demonstrate lean principles within the mob.
Uncover the concept of "Productive Paranoia," and understand the impact of real vs. artificial crisis modes on work dynamics. Is it possible to channel the benefits of crisis-mode work into non-crisis projects without causing destruction? Giovanni shares his thoughts not only on this but also on coaching in a crisis and whether non-XP ways of working naturally lead to crises.
Don't miss this high-energy, high-insight episode as we unravel the secrets of how a team mastered a high-stakes arena through Mob Programming. Tune in and immerse yourself in the world of ensemble teaming like never before!
Video and show notes: https://youtu.be/-tgjrd8sL2U
Welcome to another exciting episode of The Mob Mentality Show! In this episode with André De Sousa we dive deep into the innovative approach of Agile@School® methodology and its transformative impact on education.
Join us as we explore various facets of this groundbreaking methodology, including pairing and mobbing within the school environment, the criteria for selecting pairs/mobs and granting autonomy to students. André De Sousa sheds light on how work is allocated and curated, alongside discussions on eduScrum, curriculum, excellence, and code quality.
Discover student reactions to newfound autonomy, the significance of reflection and retro cadence, and the broader scope of the methodology across different educational settings. André shares insights into the integration of Agile@School® in coding schools, emphasizing its unique aspects compared to traditional educational experiences.
We unravel the remarkable journey of a school story, evolving from a modest start to educating 450 students within six years, some of whom began with no prior coding experience. Listen as we explore the pivotal roles of mentors, their inspiring influence on students, and how former students contribute by teaching current peers.
Intrigued by the logistics of "20% Google Time," apprenticeships during degree programs, and subsequent job offers post-degree? André discusses experimentation, failure, Kanban Gemba Walk, and constructive feedback mechanisms among students.
Learn about the impressive results achieved by the school by the third and fifth year, the emotional responses and feedback from students, and the ambitious scaling to two classrooms. This episode is a treasure trove of insights into a methodology reshaping the educational landscape.
Tune in for an inspiring and informative discussion that could revolutionize the way we perceive and approach education. Don't miss this episode of The Mob Mentality Show!
Video and show notes: https://youtu.be/c0tRUTQkPV0
Welcome to another exciting episode of the Mob Mentality Show! Today, we're diving into the fascinating world of MicroObjects with the creator himself, Quinn Gil. Prepare to unravel the intricacies of object-oriented programming practices taken to the next level.
In this episode, we embark on an exploratory journey covering a multitude of key aspects:
- Mastering MicroObjects & OOP: Quinn guides us through the world of MicroObjects and how they dial up traditional object-oriented programming practices.
- SRP to the Extreme!: Quinn explains how MicroObjects takes the Single Responsibility Principle (SRP) to new heights, making emergent design and evolutionary architecture unavoidable.
- Ruthless Refactoring: Discover the art of ruthless refactoring - a key practice that MicroObjects emphasizes for keeping code highly resistant to code rot.
- Knowledge Transfer to Code: Learn effective methods for having a representation for every concept exist in the code.
- MicroObjects Principles Debated: Join us as we discuss many of the key MicroObjects principles including no 'new' inline, no primitives, composition over inheritance, no enums, no constructor logic, wrapping 3rd party code, and preventing yourself from doing bad things.
- Persuading Others to Try MicroObjects: Quinn shares insights into effectively persuading your team to try MicroObjects, highlighting its benefits and advantages including stuff getting done faster.
- Defeating the Sunk Cost Fallacy: Understand to overcome the sunk cost fallacy with code, leading to better decision-making in development.
- TDD and Design Discovery: Explore the powerful synergy between Test-Driven Development (TDD) and design discovery, and how it can enhance your development process.
Join us for an engaging conversation packed with wisdom and expertise, as we unravel the secrets of MicroObjects and its impact on software development. Whether you're a seasoned developer or just starting out, this episode offers valuable insights into optimizing your coding practices and elevating your projects to the next level.
Tune in now to unlock the potential of MicroObjects!
Video and show notes: https://youtu.be/W6C1C9i78Ec
Join us in this episode of the Mob Mentality Show where we venture into the realm of fostering deep listening and understanding within mob programming. In this discussion, we unveil the profound 5th Habit of a Highly Effective Mobber: Empathetic Listening, drawing inspiration from Stephen R. Covey's timeless "7 Habits" book.
🎧 Episode Highlights:
- Seek First to Understand, Then to Be Understood: Exploring Covey's fundamental principle and its profound impact on effective communication.
- Empathy Pathways through Patterns and Diagrams: From "Everyone Draws" Patterns to Causal Loop Diagrams and Decision Trees - navigating empathy for enhanced understanding.
- Literary Wisdom on Empathy: Delving into a powerful empathy quote from "To Kill a Mockingbird" and its timeless relevance.
- Empathy Mocked: Uncovering humor and lessons in fake "Reflective Listening" from The Office sitcom 😅.
- Autobiographical Listening: Understanding its pitfalls and the path to true empathy in our listening approach.
- Mob Programming and Empathetic Driver/Navigator Pattern: How this naturally embeds reflective listening, promoting empathy in the team.
- Philosophical Musings: Reflecting on the epistemological empathy question, "What Is It Like to Be a Bat?"
- Benefits Beyond Perfection: Acknowledging the gains of empathy, even in imperfect attempts, and its positive impact on team building.
Tune in and enrich your understanding of the 5th Habit - an essential pillar for every highly effective mobber. 🌟
Video and show notes: https://youtu.be/RqazNQKZ0bM
Join us in this episode of the Mob Mentality Show as we embark on a journey to unravel the intricacies of happiness tracking and its correlation with the Satir Change Model. Delve into the world of team dynamics, psychology, and the power of tracking in both in-person and remote mob settings.
Episode Highlights:
- 🌟 Uncover the origin story and the overview of happiness tracking within mobs.
- 🌍 Explore the differences between tracking in-person versus remote.
- 📊 Analyze the comparison of tracking data for individuals versus a visual representation encompassing an entire organizational spectrum.
- 🔄 Understand how tracking acts as a catalyst for experimentation and continuous improvement within mob environments.
- 🗓️ Gain insights into the contrasting approaches of tracking recent versus long-term happiness trends and their implications on team dynamics.
- 💬 Explore the need for Radical Candor and Psychological Safety while tracking happiness.
- 🎯 Delve into the intriguing question: Is tracking happiness synonymous with tracking the Satir Change Model?
- 🧩 Unlock the potential of pattern thinking for happiness tracking.
- 🚨 Discover how tracking serves as an indicator for identifying mobs in need of support and intervention.
- 🤔 Tracking necessary in a healthy mob with frequent mini-retros?
- 🗣️ Learn about the crucial role tracking plays in unearthing silent dissatisfaction and fostering open communication within mobs.
- 🌟 Gain valuable insights through real-life examples of coaching based on varying levels of happiness, from low to high.
Tune in to this episode that explores the intersection of happiness tracking and the Satir Change Model. Equip yourself with practical knowledge and actionable strategies to foster joy and well-being within your team or organization. Don't miss this opportunity to embark on a transformative journey toward a happier, more effective mob environment!
Video and show notes: https://youtu.be/yBuwU-QwBSc
Are you ready for an unprecedented glimpse into the dynamic world of remote mob programming? Join us in this exclusive episode of the Mob Mentality Show, where we provide an inside look into the innovative realm of code crafting and ensemble programming.
Episode Highlights:
🔍 Behind the Scenes - Mobbing Environments: Take a tour of our in-person and remote mobbing environments, witnessing the transformation brought about by the advent of remote work. Explore the intricacies of our morning learning hour and delve into the specifics of 5 diverse mobs, from tech stack to team switching frequency.
🚀 Synergy of Code Craft and Ensemble Programming: Discover how ensemble programming fuels the creation of well-crafted, high-quality software. Uncover the various elements, from defect prevention to sustainable pace, that constitute the core of successful code crafting.
🎙️ Lean Coffee Discussion: Engage in a stimulating Lean Coffee discussion covering critical topics such as hiring practices for crafters, the nuances of the Inverse Conway Maneuver, the importance of working agreements, and the unique challenges and advantages of remote mob tools.
Embark on this eye-opening journey into the heart of collaborative software development. Witness the power of collective intelligence and the art of crafting software that truly stands the test of time. Watch now and immerse yourself in the future of code crafting!
Video and show notes: https://youtu.be/GCfUrNCxbgc
Are you ready to dive deep into the essence of software development? Join us in this enlightening episode of the Mob Mentality Show as we explore the core principles and fundamentals that underpin successful software development with the exceptional Bryan Finster.
Episode Highlights:
🛠️ Mastering the Basics: Discover the timeless importance of software development fundamentals. We break down the essential elements that lay the foundation for excellence.
📝 Agile Story Slicing: Learn the art of breaking down complex tasks into manageable chunks, a fundamental skill that empowers developers to deliver quickly and iteratively.
🛡️ Refactoring and Testing: Explore the vital roles of refactoring and testing in the pursuit of software greatness. Understand why they are indispensable components of the development process.
💎 Shiny Garbage Dilemma: Bryan unveils the common pitfall of delivering "shiny garbage" and shares insights on how to avoid this trap.
🤝 Coaching Conflict: Navigate the nuances of coaching conflict within development teams. Discover effective strategies for fostering healthy debate and growth.
🤔 Vendor Tools Demystified: Bryan delves into the world of vendor tools, offering guidance on distinguishing between the valuable and the overhyped.
📚 Learning Fundamentals: We explore the balance between learning vendor tools and mastering the fundamentals of software development.
📈 CD Fundamentals: Bryan addresses the learning curve associated with Continuous Delivery (CD) fundamentals and whether they are attainable for everyone.
🔍 Real-time Feedback: Understand why real-time feedback is the lifeblood of agility. Explore the critical role it plays in maintaining a responsive development process.
🛠️ Rock vs. Nail Gun Analogy
👁️ Demonstrating Good CD: Learn how to demonstrate effective Continuous Delivery practices in a non-prescriptive manner.
🏗️ Microservices Wisdom: Delve into the world of good design and testing to prevent catastrophic microservices failures.
🥒 True BDD and Microservices: Explore the true meaning of Behavior-Driven Development (BDD) in the context of microservices.
📜 Contract Driven Development: Uncover the principles of Contract-Driven Development and why it is crucial for scalable, maintainable designs and teams.
🤖 "No Frameworks" Philosophy: Bryan shares insights on adopting a "No Frameworks" approach and the value of problem-solving with a Minimum Viable Continuous Delivery mindset.
💬 Messaging CD: Learn how to effectively communicate Continuous Delivery concepts with kindness, honesty, and respect.
📊 Destructive Dashboards: Explore the dangers of relying on individual metrics and the pitfalls of poorly designed dashboards.
Tune in to this episode filled with wisdom, insights, and a fresh perspective on software development. Don't miss this opportunity to enhance your understanding of software development fundamentals. Watch now to embark on a journey toward software excellence!
FYI: Video and show notes to be posted here in the next day or so.
Join us on an enlightening journey into the world of software development internships in this episode of the Mob Mentality Show titled "The Intern Mob Chronicles." We sit down with Eduardo Lopez and Jeric Baga, who share their notable experiences and insights from their unique mob programming internship journey.
Episode Highlights:
🚀 Mob Programming Internship: Eduardo and Jeric take us through their adventurous journey as interns in a dynamic mob programming environment.
🔍 The Application Process: Discover how they learned about the internship opportunity and successfully applied to be part of this rare experience.
🤝 Mob-Style Interviews: Get a behind-the-scenes look at what it's like to be interviewed in a mob programming style, alongside 20 other candidates, all at the same time.
🌄 The Beginning: Explore the initial stages of their internship and how they embarked on this adventure.
🏢 Hybrid Work: Understand the challenges and advantages of working in a hybrid setting, combining remote and in-person collaboration.
💻 First Katas: Dive into their first coding challenges, working alongside fellow intern co-workers.
🤔 Code Project Selection: Discover how they chose a code project to work on as part of their mob programming journey.
🌐 Mob Tour: Join them on a tour of various full-time engineer mobs and gain insights into their diverse experiences.
⏳ The Middle: Navigate through the middle phase of their internship, including how they handled disagreements among interns.
🚀 Innovation and Discovery: Explore the innovative and collective discoveries made during their time in the intern ensemble.
🧠 Learning from Experts: Understand what it's like to mob with and learn from full-time software engineers, including mastering different Test-Driven Development (TDD) styles.
🎉 End of Internship: Hear about the exciting events that marked the conclusion of their internship, including mob demos and presentations.
😄 Humor as a Tool: Learn how humor played a role in their intern mob experience.
🏆 Biggest Wins and Struggles: Eduardo and Jeric share their most significant achievements and challenges while ensemble programming in an intern mob.
🔄 Role Reversal: Explore the unique perspective of Eduardo and Jeric as they transitioned from interns to coaches, guiding the most recent intern mob.
🎥 Behind the Scenes: Get an insider's view of the inner workings of the internship program as seen from the perspective of coaches.
📈 Program Improvements: Discover the recent improvements made to the mob internship program, ensuring an even better experience for future interns.
Don't miss this captivating episode filled with firsthand stories, lessons learned, and valuable insights from Eduardo Lopez and Jeric Baga's remarkable journey as mob programming interns. Subscribe now to the Mob Mentality Show and embark on a exciting exploration of the world of software development internships!
FYI: Video and show notes to be posted here in the next day or so.
Experience a unique twist in this episode of the Mob Mentality Show! Instead of Chris and Austin interviewing a special guest, the very special guest Dustin Thostenson takes up the mantle of hosting and interviews Chris and Austin.
Dustin leads a discussion that delves into the unique journey of the Mob Mentality Show. Explore the evolution of the podcast through its inception, guiding principles, and the impactful connections to the world of software development.
Episode Highlights: 🎙️ Journey back to the origins with the inception story of the Mob Mentality Show. 🏆 Uncover the bedrock principles that propel the podcast and the synergy with software development. 🚀 Gain insights into the inspirations and hurdles that marked the monumental release of the first episode. 🔍 Reflect alongside Chris and Austin on the lessons learned after 205+ episodes. 🔑 Dive into Chris and Austin's go-to product development principles and practices 🤝 Navigate the art of constructive discourse as we uncover the strategies for handling disagreements. 🌟 Explore aspirations for future Mob Mentality Show guests 💡 Look ahead at exciting ideas for upcoming Mob Mentality Show episodes
Join us for an engaging episode where the creators become the subjects. This special episode unveils the essence of the Mob Mentality Show and its deep connection to the world of software development. Tune in now and embark on this journey with Dustin, Chris, and Austin.
FYI: Video and show notes to be posted here in the next day or so.
Join us as we seek to unlock the secrets of optimizing communication for lean flow in this illuminating episode of the Mob Mentality Show: "The Inverse Conway Maneuver." Come along with us as we navigate the intricate landscape of software development dynamics, exploring the deep connection between effective communication and software architecture.
Episode Highlights: 🔑 Gain an understanding of Conway's Law, a cornerstone of software development dynamics. 🏢 Delve into the intriguing interplay between organizational structure, communication effectiveness, and software boundary design. 🌐 Explore the Bonker's World's org charts for tech giants like Amazon, Google, Facebook, Microsoft, Apple, and Oracle. 💡 Discover the hidden implications of Conway's Law on mob programming and collaborative software development. 🚀 Unveil the power of building significant software achievements through the synergy of small, autonomous, agile teams. ⚙️ Introducing the Inverse Conway Maneuver: A strategic approach to balancing communication for lean flow. 📈 Dive into the thought-provoking debate: When does increasing or decreasing communication enhance lean flow? ⏰ Address the pain points of stand-up meetings and uncover effective strategies for streamlining them. 👥 Navigate the challenges posed by expansive teams and explore the dynamics of full-stack teams versus specialized ones. 🔁 Responses to Conway's Law: The crucial choice between ignoring, accepting, or employing the Inverse Conway Maneuver.
Join us in this episode as we unravel the intricate threads of communication, collaboration, and organizational dynamics in the realm of software development. Don't miss this opportunity to enhance your understanding of the Inverse Conway Maneuver and its potential to revolutionize your approach to lean flow. Watch now to embark on this journey with us!
FYI: Video and show notes to be posted here in the next day or so.
Welcome to another exciting episode of The Mob Mentality Show! In this installment, we're taking a deep dive into the enthralling world of leadership as inspired by the iconic movie "Top Gun: Maverick." Get ready to soar as we explore the distinct leadership styles of Maverick, Iceman, and Warlock, and reveal how these styles can be harnessed to elevate your team dynamics, product development, and coding endeavors.
Join us as we dissect the multifaceted leadership approaches showcased in the film, and unlock the secrets to their applicability in the fast-paced realms of software development, mobbing, and code collaboration. From conflict resolution to prioritization, we'll unveil the pearls of wisdom you can integrate into your own professional toolkit.
First, we delve into Iceman's leadership ethos, a journey marked by the support and guidance he offers from high up in the org. Discover how "stacking the deck" can strategically shape your team's path to triumph, and learn the art of standing up for your team's principles even when faced with daunting pressures.
Then, we shift our focus to Warlock's method, exploring his penchant for leading through classroom training and deliberate practice. Tune in to understand the power of teaching from the back of the room, and gain insights into leading with impactful feedback that spans before, during, and after work sessions.
Last but not least, we unravel Maverick's captivating leadership style, defined by his immersive presence within his team's trenches. Witness the magic of guiding from the frontline, seamlessly blending work and coaching. Learn how to exemplify excellence through demonstrations of quality code practices and superior teaming virtues. Plus, discover the transformative potential of proving what's achievable by rolling up your sleeves and accomplishing goals alongside your team, while distinguishing the difference between learning theft and the strategic "I do, we do, you do" approach.
Tune in to this riveting episode of Mob Mentality and glean insights that transcend cinematic narratives. Uncover leadership approaches that could revolutionize your team's dynamics, and gain a fresh perspective on how to harness the remarkable qualities of Maverick, Iceman, and Warlock in your leadership journey. Don't miss out—hit that play button now and let's embark on this exhilarating leadership expedition together!
FYI: Video and show notes to be posted here in the next day or so.
Dive into the realm of dynamic reteaming and self-selection with the insightful Paige Watson in this episode of the Mob Mentality Show. Join us as we explore the exciting evolutions of becoming accidentally FaST and discover how to harness its power for enhanced team collaboration and innovation.
Episode Highlights: 🚀 Explore a quick intro to FaST (Fluid Scaling Technology) and its transformative impact. 🌟 Gain insights from Paige's personal experiences with FaST. 🌀 Uncover the gradual transition to FAST methodology through a series of small, impactful decisions. 🔬 Delve into the advantages of discovering together through experimentation over traditional top-down directives. 🏘️ Discover how FaST enhances team ownership and fosters a sense of collective responsibility. ⏱️ Is FaST truly faster? 💡 Choose work based on passion and expertise, aligning with the core principles of FaST. 🤝 Unleash the potential of FaST mobs, revolutionizing collaborative productivity. 🏢 Explore the leadership and system-level needs for successful FaST experimentation. 📊 Examine metrics for evaluating the effectiveness of FaST teams, focusing on both individual and collective success. 📈 Measuring individuals vs. measuring teams: How FaST redefines performance evaluation. 🌐 Is FaST universally for all? 🔥 Navigate healthy conflict within teams. 📜 Dive into Agile Manifesto principles "self-organizing teams" and "motivated individuals" in the context of FaST. 👥 Should the deck be stacked for healthy team composition? 🔍 Experiment with the dynamic reteaming and self-selection. ❓ Address the question: Can self-selected teams ever lead to ineffective outcomes within the FaST framework? 📛 Tackle the challenge: What happens when self-selection leads to tasks nobody wants to undertake? 🛠 Explore the viability of a self-selected FaST team without prior XP skills and its potential for success. 🤹♀️ Dive into the potential repercussions of excessive team switching within a FaST team and the loss of context. 🤼 Reflect on the significance of interpersonal and facilitation skills in a self-selected FaST team. 🛡️ Uncover the mechanisms of team self-regulation within the FaST framework and its implications.
Embark on this enlightening journey of Accidentally FaST, dynamic reteaming and self-selection. Tune in now and gain valuable insights from Paige Watson on harnessing the power of FaST for team agility!
FYI: Video and show notes to be posted here in the next day or so.
In this exciting episode of Mob Mentality, we are joined by the excellent Kevin Callahan, a master in Leadership Wayfinding. Join us as we explore the organic art of pathmaking in uncharted territories, and discover how to lead with confidence and adaptability in the face of unpredictability.
Episode Highlights: 🧭 Learn the art of guiding your team through unfamiliar landscapes with skill and finesse. 🔍 Uncover the fascinating history and metaphor behind the term "Wayfinding" and its relevance in leadership. 📈 Why Wayfinding vs. Taylorist Style Big Upfront Plans: Delve into the contrast between and how the former thrives in complexity. 🌌 Explore the interplay between complexity theory and the challenge of predictability in leadership. 🔧 Equip yourself with strategies to navigate and adapt to unexpected changes with confidence. ✅ Discover the power of checklists as tools for managing uncertainty and ambiguity in leadership. ⚙️ Learn from real-world examples when managing changes that were too big and their consequences. 📋 Utilize Kanban visualization and batch size experimentation for enhanced efficiency. 💡 When Enterprise Coaching Goes Well and Goes Wrong 🔄 Learn how to embrace and recover from failed experiments, fostering a culture of growth and learning. 🤝 Understand the importance of humility and radical candor in building strong leadership and consultant connections. 🏢 Team vs. Enterprise Level Complexity 🛣️ Master the art of making a rapid series of small decisions to maintain safety and stability. 🎯 Enterprise Kanban and Visualization 🔎 Leverage the Cynefin framework for informed decision-making in complex environments. 🗣️ Enhance your coaching skills with effective probing, sensing, and responsive techniques. 📏 Gain insights from queuing theory for optimizing workflow and productivity. 🏭 Unravel the applicability of successful team-level practices at the enterprise level. 🧪 Learn how to align with natural laws governing industries and systems for sustainable success. 💼 Define and recognize value within the broader context of enterprise operations. ⌛ Identify and minimize organizational wastes for streamlined efficiency. 🤝 Examine enterprise collaboration practices between departments, groups, and workflows. 🎼 Enterprise Ensembles? 🏢 Embrace holistic perspectives by bringing the entire system together for meaningful dialogue and decision-making.
Join us for this insightful episode filled with strategies and practical wisdom on Leadership Wayfinding in an ever-changing world. Watch now and embark on your journey towards becoming a more agile and adaptable leader with Kevin Callahan as your guide.
FYI: Video and show notes to be posted here in the next day or so.
Are you eager to assemble a lean and effective XP team? In this action-packed episode of Mob Mentality, we sit down with Jim Speaker to unravel the secrets of crafting agility within your organization. Join us as we delve into the art of creating a small XP team that's agile, proficient, and ready to craft code.
Episode Highlights: 📝 Learn about job descriptions crafted to align with the agile XP principles and practices. 🚀 Discover strategies to build a nimble and dynamic XP team, capable of navigating any challenge. 📚 Gain valuable insights into the journey from crafting job descriptions to successfully hiring the right candidates. 🤝 Unlock the potential of pair and mob programming during interviews to bring out the best in candidates. 🎓 Create an environment where both candidates and interviewers can learn from each other. 🛠️ Explore Jim's passion for craftsmanship, XP principles, and the art of dealing with legacy code. 🧩 Unravel the dilemma of choosing between specific tech stacks and XP principles when hiring. 🔥 Learn from Jim's experiences of dealing with challenges when hiring senior developers. 🗣️ Decode the art of discerning authentic candidates from those who merely play buzzword games. 🌟 Explore the advantages of hiring entry-level developers with a thirst for learning and growth. 🧠 Embrace the essence of tacit expert knowledge and its impact on craftsmanship. 🤼 Discover Jim's personal journey of overcoming pairing challenges and reaching new heights. 🔄 Understand the journey of experimentation from Scrum to Kanban to No Estimates, and the insights gained along the way. ⛓️ Grasp the concept of flow in an XP team using the conveyor belt analogy. 🎣 A shoutout to Jim's Hatchpedia App built on the Uno Platform.
Tune in to this extraordinary episode filled with practical insights and actionable tips on building a lightweight XP team that thrives in a dynamic, ever-changing environment. Don't miss out on this opportunity to learn from the passionate XP enthusiast, Jim Speaker. Subscribe now and embark on your journey towards crafting true agility within your team!
FYI: Video and show notes to be posted here in the next day or so.
Welcome to a fascinating episode of Mob Mentality, where we jump into the world of learning, cognition, and neuroscience with the brilliant Barbara Oakley. Join us as we explore the secrets behind learning how to learn, which is essential in product development, tech, agile, engineering, and beyond.
In this mind-expanding conversation, Barbara Oakley will share valuable insights from her expertise in cognitive psychology and neuroscience. Discover the science of learning as we unravel the illusions of competence that hinder cognitive growth. Learn how dopamine influences our motivation to learn and the role of retrieval in diagnosing intellectual development.
For all the tech enthusiasts out there, we'll explore the significance of code katas, computer programming, and practice enrichment in becoming a master of your craft. Understand the importance of mastering habits, learning facts, and utilizing cognitive psychology to enhance your learning process.
But that's not all – we'll delve into the world of group learning and mob skill development, where neuroscience plays a pivotal role in optimizing team performance. Uncover the power of interleaving techniques and how they contribute to accelerated learning.
Ever wondered about the impact of brain fatigue on learning and working? We've got you covered. With the lens of neuroscience, discover how efficiency is lost via task switching and learn about the fascinating concept of "supertaskers" in comparison to the rest of us.
Join us as we explore various methods of acquiring knowledge, including speaking, hearing, and typing, and uncover the science behind spaced repetition and Pomodoro.
Not forgetting the significance of sleep in the consolidation of knowledge and the refactoring of grey matter. We'll also discuss the responsible use of AI tools without negatively affecting human learning and problem-solving abilities.
Intrigued by why IQ may decline over time? Tune in to find out the reasons behind this phenomenon and how person formation during memorization and learning plays a significant role.
Are you ready to explore the "Map Habit" and its impact on knowledge retention? We'll also touch upon the surprising benefits of action video games on the elderly and their brains.
Prepare yourself for a knowledge-packed episode that will transform your understanding of learning, cognition, and the human brain. Join us for an unforgettable discussion with Barbara Oakley on Mob Mentality!
Don't forget to like, share, and subscribe to support our channel and stay updated on more thought-provoking content.
FYI: Video and show notes to be posted here in the next day or so.
Welcome to the latest Mob Mentality Show episode, where we dive deep into the world of improvement and overcoming obstacles. In this episode we are joined by special guest Eddie Bush to explore "The Improvement Paradox: Why Don't We Improve and How to Overcome It."
Join us as we uncover the reasons behind our struggles with improvement, including the delays between cause and effect, the psychology of quality flip flops, and the fear of change. We'll also discuss the false shortcuts to improvement and the chain of pressure cookers that hinder progress.
Delve into the concept of Lean Flow Thinking and the importance of focusing on the whole system rather than what is easy to measure. We'll also explore the diametric opposition between leadership goals and improvement, as well as the empathy required for leadership transformation.
Discover the joy of an XP (Extreme Programming) shop and the apparently necessary non-XP experiences to become an XP person. We'll also touch upon the foundation of solid product quality and the correlation between speed, quality, and customer retention.
Uncover the benefits of measuring improvement via DORA metrics and unlocking product experimentation. Learn about the prerequisites for transformation and the vital role of coaching in improvement, including the player/coach dynamic and the economy of trust.
Explore the challenges of coaching impostor syndrome and setting improvement work-in-progress limits. We'll also tackle the importance of buy-in at the top for successful change and the impact of Westrum culture on improvement efforts.
Join us as we discuss the necessity of creating space for improvement, the relationship between safety and improvement, and the role of delivery in enabling improvement. We'll even touch upon Code Craft Saturdays and Sundays, highlighting the significance of continuous learning and practice.
Tune in to this enlightening episode filled with valuable insights and strategies to overcome the improvement paradox. Don't miss out on the opportunity to boost your own improvement journey!
FYI: Video and show notes to be posted here in the next day or so.
Join Chris and Austin in this episode of The Mob Mentality show as they explore the captivating world of code katas with special guest Steve Kuo. Uncover the secret behind the reigning king of them all: FizzBuzz. Delve into a conversation about deliberate practice, motivation, grit, and feedback. Discover the art of becoming a master in any field and unravel the immense value of repetition and focus.
Explore the concept of how much repetition is necessary for mastery and whether it can have a negative impact on team motivation. Brace yourself for tales of katas gone wrong and the common misunderstandings surrounding code katas.
Gain insight into the key mindset required for successful katas and learn the importance of starting with the question, "What am I going to practice today?" Dive into the world of pair, mob, and collaborative katas, and understand their significance in honing your skills.
But why is FizzBuzz hailed as the best code kata around? Unearth its remarkable versatility as a tool not only for learning programming languages but also for grasping design patterns and daily warmups. Discover how FizzBuzz can even teach you the art of ensemble and serve as a psychological safety tool.
Explore the connection between grit and craftsmanship, and contemplate the question: "Are you what you do when no one is watching?" Uncover the intriguing phenomenon of semantic diffusion within the world of craftsmanship and how it influences our perception of skill.
Lastly, Steve ends with a teaser on the six-minute interview. Tune in to this episode and immerse yourself in the magic of FizzBuzz and the transformative power of deliberate practice.
In this exciting episode, we dive into the world of Mob Programming with AI on Test Automation. After a quick intro on Mob Programming, we explore the benefits of testing with both human friends and robot friends. We'll share our fascinating origin story of Mobbing with a Robot and explore how AI can drive test development in an ensemble. Discover how testing with robots can help us uncover ZOMBIES and learn about the limitations and warnings of this approach. Watch an AI Mobbing Demo where ChatGPT generates a Flutter app with unit tests, and witness the power of AI-generated test ZOMBIES using Copilot. Don't miss this opportunity to explore the intersection of AI, Mob Programming, and Test Automation!
FYI: Video and show notes to be posted here in the next day or so.
Welcome to a transformative episode featuring the remarkable Joshua Kerievsky, where we unlock the secrets to finding joy in agility. Join us as we embark on an journey through life, business, and tech, discovering the Wooden Way to balance, resilience, and rapid adaptation.
Prepare to hear about the power of combining short stories and principles as Joshua shares insights on selling the invisible. Explore the art of being poised to adapt in the face of unexpected events, as illustrated by a Richard Branson story.
Say goodbye to heroics as we dive into the world of agility and ensembles, witnessing the incredible learning and interpersonal wins that arise from embracing collaboration and diversity of opinion. Discover the importance of taking responsibility for your own learning, accompanied by an intriguing "It Was All Greek to Me" story.
Uncover the perils of learned helplessness and the liberating potential of rapid experimentation. But the journey doesn't end there. Join us as we explore the wisdom of Benjamin Franklin, feedback, and the art of naming, all while reflecting on the timeless significance of great books, ensembles, classical education, and "Classic Agile."
Don't miss this episode where passion, agility, and wisdom collide.
FYI: Video and show notes to be posted here in the next day or so.
Join us as we explore unlocking true collaboration with the win-win mindset in the fourth habit of a highly effective mobber. We share experiences on the pitfalls of win-lose and lose-win scenarios within a mob and uncover the spirit of abundance versus scarcity mentality. After walking through the principles of "win-win or no deal" and the benefits of high consideration and high courage within a mob, we cover the challenges of low courage or low consideration. In response we share strategies for coaching and helping ensembles overcome these hurdles. Lastly, come discover the nuances of win-win internally within a mob vs. inter-team collaboration.
FYI: Video and show notes to be posted here in the next day or so.
Join us as we explore the transformative benefits of mob programming in a software dev internship program, taking you on a journey from interviews to potential full-time hires.
Discover how we interview 10-20 intern candidates at once using mob programming, revolutionizing the way we assess their skills and potential. Explore the pros and cons of interns joining existing mobs versus having an independent intern-only mob, and learn the key steps to prepare for the intern mob experience.
We deep-dive into the essential aspects of intern mob onboarding, project selection, and the crucial roles of intern mob coaches. We share how we witnessed the incredible growth as interns present their end-of-project demonstrations and gain valuable "agile" training at the culmination of their internship. But the journey doesn't end there – we delve into the exciting possibilities that follow the internship.
Don't miss this episode that combines the power of mob programming, internships, and agile practices.
FYI: Video and show notes to be posted here in a day or so.
Get ready to explore the dynamic world of living documentation and open source software in this episode with Steven Baker. Join us as we uncover the benefits and challenges of executable documentation and how it helps to keep your team's knowledge in sync. Discover the origins of the "describe/it" pattern and RSpec, and learn how to infuse domain into your tests for enhanced understanding.
Next we turn our attention to the implications of GPL and "Copy Left" licenses, and gain valuable tips on understanding your responsibilities within the FOSS licensing landscape. We also touch on the fascinating intersection of AI and open source software, avoiding open source developer burnout, and seeking help within the FOSS community. But that's not all – are you curious about remote work from remote places? We briefly discuss the joys of remote work. Don't miss out on this eye-opening conversation filled with practical advice, experiences, and valuable insights.
FYI: Video and show notes to be posted here in the next day or so.
Have you ever wondered why some teams struggle to adopt Test-Driven Development (TDD) while others excel at it? Join us in this thought-provoking episode as we delve into the challenges of crossing the TDD chasm and explore testing strategies with the insightful Khaled Souf.
Are you tired of "freestyling" with no tests? Do you find TDD too hard? We address these questions and more as we discuss the human side of trying to adopt TDD and respond to resistance along the way. Discover the power of supportive guidance and learn how to create an environment where teams can thrive and contribute.
But that's not all – we also dive into the world of ensemble programming and the traps that teams often encounter. From the "No Safe Space Trap" to the "Big Steps Trap," we uncover the obstacles that can hinder progress. Find out how to establish lean flow and minimize waste within an ensemble, and explore the balance between strict equality of navigation and minimum viable silence.
We also explore the synergy of legacy code and Domain-Driven Design (DDD), showcasing how DDD can be applied while fixing bugs.
Don't miss this engaging conversation packed with insights, practical advice, and real-world examples. Subscribe now to our podcast and YouTube channel to be notified when episodes are released.
Video and Show Notes: https://youtu.be/XFHzZMlckzU
Join us for the latest episode of Mob Mentality, where we dive deep into "The 3rd Habit of a Highly Effective Mobber: First Things First (7 Habits)." Our conversation explores the importance of scheduling your priorities instead of prioritizing what's on your schedule. We discuss the Eisenhower Matrix and how it can be used in mob programming, and we also examine the urgent and important trap. Additionally, we explore how to prevent stress, burnout, and constant fire fighting, as well as how to build deep and meaningful relationships. Throughout the episode, we provide practical tips for improving productivity and preventing crises and fires. Don't miss out on this insightful discussion.
Video and Show Notes: https://youtu.be/-9Kl5L9anOg
What is your team's center? What is the north star?
What side-effects do you observe when they are off-center?
What outcomes do you witness when the team's center is on point?
Join us for the latest episode of Mob Mentality where we delve into "Begin with the End in Mind," which is the 2nd Habit of a Highly Effective Mobber (7 Habits). Our discussion includes topics such as finding your team's north star, being people-centered vs. principle-centered, and how to help a mob find their center through storytelling and coaching.
FYI: Video and show notes to be posted here in the next day or so.
What is it like to continuously collaborate on a web app that helps people learn to continuously collaborate?
How does this free new web app automate, streamline, and add more fun to the Mob Programming RPG?
What remote tech stacks and onboarding practices keep public ensemble sessions flowing, welcoming, and enjoyable?
In this episode of the Mob Mentality Show, we talk with Gregor Riegler about "Mobbing on the Open Source Mob RPG" and demonstrate the new Mob Programming RPG Web App. We start by discussing the origin story of the app and the weekly public mob session to work on it. We also cover examples of fun, surprising, and innovative remote mob sessions, as well as a walkthrough of the app page by page. We then dive into the tech stack, tools, and collaboration methodology used in the app's development.
FYI: Video and show notes to be posted here soon.
The Mob Mentality Show is back with another informative episode titled "Certifiably Extreme with Paul Moore." In this episode, Chris Lucian and Austin Chadwick sit down with Paul Moore to talk about certifications and Mob Programming in the Certified Scrum Developer Course. They cover a range of topics, including the potential benefits and drawbacks of certifications, mob makeup in the CSD course, story splitting value and techniques, and the hole in the Scrum framework. Join the conversation as they explore the world of agile development and learn how to become "Certifiably Extreme." Don't miss out on this insightful episode! Subscribe to the Mob Mentality Show and stay tuned for more.
FYI: Video and show notes to be posted here in the next day or so.
Get ready for a stimulating new episode of the Mob Mentality Show! In "Copilot: Mobbing with a Robot," we delve into the exciting world of extreme programming with Copilot.
How does Copilot stack up against ChatGPT in the mob?
Is Copilot a verbose extrovert mob navigator while ChatGPT is a reserved introvert?
What happens when you teach Copilot humor and memes?
And how can we "jailbreak" AI for good versus evil?
Join us as we explore all this and more, including using AI in interviews, setting context for Copilot with comments, and letting robots and humans each do what they do best. Don't miss out on this fascinating discussion!
FYI: Video and show notes to be posted here in the next day or so.
What is it like to onboard a new robot to your team?
How well does the generative AI navigate code on day one in an ensemble?
What are effective ways the mob can interact well with ChatGPT? What ways are not so effective?
Join us as we share our experiences with ChatGPT and Mobbing with a Robot. We first tell the story of ChatGPT joining a mob team for a month to work on a greenfield mobile app. Next we explore the times when the robot helped to produce great code with the ensemble vs. more problematic code. We then dive into the legal implications of having generative AI in the team. Lastly, we talk about setting the context for ChatGPT to be an extreme programmer, how this changes the researcher role in the mob, and how to capitalize on a robot's sense of humor while teaming.
FYI: Video and show notes to be posted here in the next day or so.
How do you listen to code?
What elicits the most accurate and helpful information from the software?
After you feel you understand the code, what is the most effective way to tame and change it?
Join us as we explore The Art of Code Whispering with Brett Schuchert. We kick it off by talking about how "Not Alone-ing" helps with code whispering. Then we discuss executing code to listen to it , TDD, and truly understand code before changing it. Lastly, we get Brett's take on lean product development flow and things he looks for when joining a team.
FYI: Video and show notes to be posted here in the next day or so.
What is predicting software development like?
For example, is it more like forecasting a hurricane? Or, more like forecasting the repeat manufacturing of a physical widget?
What is the appropriate level of certainty? What effect should that have on our product thinking and practices?
Join us as we explore predictability and flow with Daniel Vacanti. We not only discuss forecasting hurricanes vs. forecasting product development, but we also dive into thinking in bets like a poker player, continuous forecasting, and bankroll management. We talk through the marketability of rational uncertainty vs. overconfidence. We round it out with planning, kanban, flow, and foundational flow metrics like work item aging.
FYI: Video and show notes to be posted here in the next day or so.
Do you have any experience managing individuals on a team? How did it go?
Alternatively, have you ever resisted the urge to manage and incentive individuals and instead focused on the system, mob/ensemble, or team? What would that be like?
What are the pros and cons of either approach?
Join us as we have a fantastic time discussing with Vitaly Sharovatov where he passionately shares about managing mob teams. First, we dive into The Candle Problem. Second, that leads us into conversationally exploring individual incentives, motivation, systems thinking, and managing mobs. Third, after connecting that to solo vs. ensemble hiring, we jump to mob onboarding, knowledge management, and knowledge systems. Lastly, Vitaly enthusiastically shares about the importance of ethics to everyday tasks in development, engineering, and management.
FYI: Video and show notes to be posted here in the next day or so.
Ever heard someone say "there's nothing we can do" in a team or mob? Or, how about "that's just the way it is"? What effect did it have on the team? What was your response?
Join Chris and Austin as they discuss The 1st Habit of a Highly Effective Mobber: "Response-ability." They start with setting the stage regarding this topic's inspiration from the books Turn The Ship Around and The 7 Habits of Highly Effective People. Then they talk about what "response-ability" means and its significance especially in an ensemble programming context. After they clarify the distinction between proactive vs. reactive, they dive into the impact of focusing on your circle of concern vs. focusing on your circle of influence. Lastly, they connect this habit to coaching, retrospectives, learning time, kaizen, and systems thinking.
FYI: Video and show notes to be posted here in the next day or so.
What is the relation between confidence vs. competence?What does that relation have to do with mob programming?
Join Chris and Austin as they discuss The Dunning-Kruger Effect. They talk about what they have discovered about The Dunning-Kruger Effect and the many different versions of the phases in the model (e.g., "Child's Hill" => "Insecure Canyon" => "Grown-Up Mountain" vs. "Ignorant" => "Cultured" => "Expert"). Then they discuss the relationship between the Dunning-Kruger Effect and mob programming, learning, experimentation, humility, and refactoring.
FYI: Video and show notes to be posted here in the next day or so.
Why do things not get done in tech? What gets in the way? What causes waiting? What causes re-work?
Join Andy Kwong, Rei Pamintuan, Aaron Griffith, and Austin Chadwick as they not only share horror stories of things not getting done, but they also share joyous stories of things actually getting done. They discuss the wastes that cause all the madness with flow. Lastly, they explain and demonstrate how mob programming has eliminated these wastes in their context.
FYI: The advertised lean coffee portion of this tech talk is not in this episode since there is a pending approval to share it publicly on The Mob Mentality Show. Video and show notes to be posted here in the next day or so.
Ever witnessed someone experience sudden agile enlightenment? What was it like? Is there a method to the magic that can be replicated? Ever seen a new idea face resistance against "the way we have always done it"? How did you handle it?
Join Chris and Austin as they discuss "Agile Satori, Meatloaf Industrialism, and Ensemble Training" with Jon Fazzaro. First, they discuss flipping the classroom, "Nerd Lunch," and ensemble training in light of "the speed of work as the speed of idea sharing." Second, they dive into Meatloaf Industrialism and our unquestioned cultural habits. Lastly, Jon shares about agile satori vs. slow gradual transformation and they discuss the relation between immersion and the paradox of paradigm shifts.
FYI: Video and show notes to be posted here in the next day or so.
Imagine you get to design a college class that teaches mob programming, craftsmanship, and agility. What would it look like? How would you do it?
Imagine no more and join Chris and Austin as they discuss with professor Paul Gestwicki his agility focused college courses and how he adapted the Mob RPG for the classroom. Paul talks about how he heard about Mob Programming via a Joe Justice video and shares about his first experiments with using Willem Larson's Mob RPG Game in the college classroom. Come hear what Paul learned from those experiments and what changes he made to the game to tailor it for his students' levels and context. They all discuss scaffolding for learning navigation skills and Paul tells a TDD and clean code game design success story. Come celebrate awesome educators like Paul Gestwicki in this episode of the Mob Mentality Show!
FYI: Video and show to be posted here in the next day or so.
How do you compile knowledge? How do you capture ideas, inspirations, insights, and connections? How do you keep it all organized? What would it look like to do this for a team or mob?
Join Chris as he explores with Vince Carpino and Jason Storey the intriguing world of second brains. First, Vince defines a second brain and shares about his productivity journey with second brains. Second, they dive into the many different implementations of a second brain ranging from Zettelkasten to Bullet Journaling to Commonplace Books. Throughout they not only talk about benefits of having a second brain but they also share their own personal experiences with them. Lastly, they give some tips for a team or mob who may want to experiment with implementing a collective second brain.
FYI: Video and show notes to be posted here in the next day or so.
After graduating, what was your onboarding experience like for your first job?What was lacking? What was good?What would it look like to turn up the good all the way for onboarding?
Join Chris and Austin as they discuss with Sean Cowan and Andy Graham their exciting ensemble bootcamp for onboarding new graduates. First, they discuss the origin story for this internal bootcamp. Second, they not only share what it is like to be a new grad in this program but they also share what it is like to be a mentor to these new grads. Lastly, Sean and Andy talk about many of the goals and principles behind the bootcamp. Come join us to find out how many new grads discover XP and craftsmanship in this onboarding process to later become positive disrupters in their first production team.
FYI: Video and show notes to be posted here in the next day or so.
Ever been in a software group that was so effective that it truly lived up to the word "team"? If so, what was it like? What was the differentiator that took it beyond the infamous office posters of so-called "teams" into the realm of actual teaming?
Join Chris and Austin as they celebrate and discuss with Woody Zuill and Kevin Meadows the second edition of the Software Teaming Book that Woody and Kevin just published. Woody and Kevin not only explore the inspiring software teaming concept from Amy Edmondson's Teaming book but also they dive into the genesis of the first and second editions of their Software Teaming book. Woody and Kevin talk about what changes were made in the second edition and why. They share about how they collaborated to write the book and why Kent Beck was asked to write the foreword. Lastly, they riff on different analogies for teaming (e.g., Orchestra, Jazz Band, Improv Comedy Group) and on the unity and diversity they have experienced in mob/ensemble programming.
FYI: Video and show notes to be posted here in the next day or so.
While the lean wastes of task switching, defects, handoffs, and relearning are certainty inhibitors of flow for a team, ever seen the waste of waiting on slow hardware muck up the works? What hardware setups for teams, ensembles, and mobs have you seen help keep things flowing?
Join Chris and Austin as they share experiences with Mob Station Hardware. Chris kicks it off with the end of Moore's Law and the implications for processor architecture. Then they both share on the impact of hardware on test speed (e.g., approval tests) and mob lean flow. After talking about pet vs. cattle hardware, they touch on hardware resilience to failure and mob resiliency to hardware failure.
FYI: Video and show notes to be released in the next day or so.
You may have heard of London style Test Driven Development (TDD). You also may have heard of Detroit or Chicago style TDD.However, what do these two styles look like "out in the wild" in real production code? How about on teams collaborating via Ensemble Programming?
Come join Chris and Austin as they share about their mob programming experiences of London TDD and Detroit/Chicago TDD. They not only talk about the pros and cons of each style but they also talk about when they have seen each style done well and each style done poorly. Then they get practical about when to "shift gears" to experiment with a different style to fit the situation of the code and the team/mob.
FYI: Video and show notes to be posted here in the next day or so.
When planning iOS work and writing iOS code, how fast are your feedback loops? How much fun are you having in your work? Are the two things related?
Join Chris and Austin as they discuss with Jon Reid how fast feedback and fun in iOS development was greatly amplified for him. They first dive into discovery trees for visualizing work. Then after some "hot takes" on the state of architecture and design in iOS development, they jump into the impact of technical practices and Extreme Programming (XP) in that iOS world. Lastly, Jon shares on the joys of finally being on a full XP team.
FYI: Video and show notes to be posted here in the next day or so.
What are things conducive to personal fulfilment at work?Specifically with mob programming, what would it look like to optimize for personal fulfilment?For example, how do you find joy even in the midst of disagreement?
Join Chris and Austin as they discuss with Kelly Rankin "Optimizing for Personal Fulfilment in Mob Programming." Starting with autonomy and fulfilment, they share what that looks like in an ensemble including things that make it harder and things that make it easier. Then they jump into kick starting and maintaining continuous learning. Lastly, they focus on keeping a holistic perspective in the work and the impact of full-stack development, which ultimately goes full circle and ties back into continuous learning and personal fulfilment.
FYI: Video and show notes to be posted here in the next day or so.
Extreme Programming and Mob Programming go together like peanut butter and jelly. However, have you ever joined an ensemble that was not doing extreme programming?How did you handle it?What reactions were helpful? What reactions were not so helpful?
Join Chris and Austin as they discuss the good, the bad, and the ugly for tactics in regards to joining a mob not doing XP. They share experiences on transparency with non-utopia ensembles including emotional shock and recovery in the midst of the coaching chaos. Then with a "center, enter, turn" mindset, they talk about specific things that have been helpful such as "getting therapy," limiting coaching WIP, "long game" mindset, encouragement, and emphasizing without patronizing.
FYI: Video and show notes to be posted here in the next day or so.
After having a good time mob programming with introductory roles like driver/navigator, what are some examples of "turning up the good" even more? What are unique ways to help people in the ensemble grow? What mobbing tactics can you employ to improve the product in very particular ways?
Picking up from where they left off last time, come join Chris and Austin having another fantastic time playing the Mob Programming Role Playing Game with Lisa Crispin, Joe Justice, and Willem Larsen. This time, they focus on embodying level 2+ roles like Sponsor, Archivist, Rear Admiral, Nose, Traffic Cop, Automationist, Anthropologist, and Dr. Feel Good. Not only do you get to see how things like "graphic kanban" can be used along side ensemble programming but you also get the feel of some of the many unique ways to contribute in a mob.
FYI: Video and show notes to be posted here in the next day or so.
Is mob programming a group of people watching one person type? Just a driver and a bunch of watchers? If not, what are some examples of things to do in the ensemble? What roles amplify learning, contribution, continuous improvement, and flow efficiency for all? How can people learn in a safe environment how to take on these mob roles?
Come see the Mob Programming Role Playing Game in action with Chris, Austin, Lisa Crispin, Joe Justice, and Willem Larsen as they focus on role levels 1 and 2. After Willem, creator of the RPG game, introduces the game, they have a fantastic time embodying several roles including Driver, Navigator, Mobber, Researcher, and Sponsor. Not only do they seek to help each other take on the different mob roles, but they also seek to do it with kindness, consideration, and respect. We hope this episode inspires you to play the game with some colleagues and friends and "join the annals of the great mobs of history."
P.S. Stay tuned next week for round 2 of the RPG in action for role levels 3+
FYI: Video and show notes to be posted here in the next day or so.
Ever been on a team that pulled off a big jump in innovation? What things made the quantum leap possible? What helped the team overcome any perceived risk in going for it?
Join Chris and Austin as they share stories and thoughts on "Taking Risks... Safely." First, they talk about following the Scout Rule for 1% gains vs. large improvement leaps. Second, they explore mob psychology in regards to risk and safety nets. Then they discuss making learning and experimentation easy with a limited blast radius including "Yes, and..." techniques vs. a flat "no." Lastly, they cover the impact of leadership, chaos, and "extreme" suggestions.
Video and Show Notes: https://youtu.be/gf56ES2ZTUE
Ever been on a team that pulled off a big jump in innovation? What things made the quantum leap possible? What helped the team overcome any perceived risk in going for it?
Join Chris and Austin as they share stories and thoughts on "Taking Risks... Safely." First, they talk about following the Scout Rule for 1% gains vs. large improvement leaps. Second, they explore mob psychology in regards to risk and safety nets. Then they discuss making learning and experimentation easy with a limited blast radius including "Yes, and..." techniques vs. a flat "no." Lastly, they cover the impact of leadership, chaos, and "extreme" suggestions.
Video and Show Notes: https://youtu.be/gf56ES2ZTUE
When coaching, when to make it easy? When to let it be hard? How can these two seemingly diametrically opposed objectives work together?
Come join the conversation with Chris and Austin as they brainstorm to try to figure out the "The Coaching Paradox." First, they share about the benefits of making a great environment where it is easy to do good things (e.g., systems thinking, classical culture shaping, etc.). Second, they talk about the pros of developing the ability to do good things even if they are hard (e.g., grit, classical courage and diligence). Then, they hypothesize on how to solve the paradox and bring the two good goals together as a coach.
Video and Show Notes: https://youtu.be/GexsVYQ4tYo
When coaching, when to make it easy? When to let it be hard? How can these two seemingly diametrically opposed objectives work together?
Come join the conversation with Chris and Austin as they brainstorm to try to figure out the "The Coaching Paradox." First, they share about the benefits of making a great environment where it is easy to do good things (e.g., systems thinking, classical culture shaping, etc.). Second, they talk about the pros of developing the ability to do good things even if they are hard (e.g., grit, classical courage and diligence). Then, they hypothesize on how to solve the paradox and bring the two good goals together as a coach.
Video and Show Notes: https://youtu.be/GexsVYQ4tYo
Imagine you are put in a leadership position at a new organization. You immediately see many problems and areas for improvement in the system. What are some of the first things that you do? What are some things that you resist doing?
Join Chris and Austin as they discuss influencing organizational change from the top/middle vs. the bottom. After Chris talks about avoiding the corporate antibody response, he shares his experiences on applying the "Center, Enter, Turn" principles. Next they discuss "unhelpful forgetting" and finish with how habits apply at the org and system level.
Video and Show Notes: https://youtu.be/gKBOxwhj2iM
For software, what things lead to excellence and continuous delivery? For teams, what is conducive to innovation? To people speaking up with ideas, questions, concerns, mistakes, and taking interpersonal risk?
Come join Chris Lucian and Austin Chadwick at this Q&A session on "High Quality, High Release Frequency, High Psychological Safety" as they share from a #MobProgramming perspective. Stemming from that foundation, then Chris and Austin pivot to these specific questions from the audience at the Talabat event: - How to keep mob programming effective remotely? - How can a manager know who to promote in a mob programming environment? - How to ensemble when there are schedule conflicts? - Can you hire for mob/ensemble programmers? - How to mob with people who do not want to mob all the time? - How can mobbing be efficient? Don't I have better things to do with my time? - How can a group of Android, iOS, and back-end developers cross-train? Is it worth the time investment? - How to prioritize what to work on next when ensembling? - How to handle complex dependencies between teams? Skill dependencies? Tech dependencies?
Video and Show Notes: https://youtu.be/gNA7cd1LQHU
What would happen if your team kept working on its current production tasks, but switched the top priority to learning while doing so? What if this flip would not only include learning facilitation excellence but also would include coaching, technical, and product excellence as well? What would the short term impact be? What effects would be seen in the mid to long term?
Join Chris and Austin as they have a fantastic discussion with Joel Tosi and Dion Stewart on "Dojos and Coaching for Learning Beyond Facilitation." After Joel and Doin describe these immersive learning environments in production, they dive into how remote dojos have led to more ensemble programming. Then, for both sports and tech, they cover the many facets of coaching side-by-side and in-context. Lastly, they explore what a post-"Agile" world looks like for them.
Video and Show Notes: https://youtu.be/BCg-_7axWVU
Ever been in an org or team where it feels like entropy reigns supreme? After some improvements, have you seen things gradually decline back into disorder and old habits?
Join Chris and Austin as they discuss "Overcoming the Groan Zone, Bad Habits, and Entropy" with Mark Pearl. First, we hear Mark's ensemble journey with tech tourism, and then we talk about tools for getting past the groan zone in a new mob. Next, we brainstorm on how to handle reverting to old habits and entropy. This leads into a conversation on tactics for leadership and facilitation tools for collective decision making.
Video and Show Notes: https://youtu.be/-Jl4iq30uFk
What is the reflection rhythm on your team? How about your team's refactoring rhythm? How do the two interplay?
Join Chris and Austin as they discuss "Reflection & Refactoring Rhythm" with Giorgio Sironi and Kevin Rutherford. After Giorgio and Keven share about the retro cadence in their ensembles and their reflection prompts, we jump into "tracer bullets" on all the things. Lastly, we discuss the "when to refactor Spidey Sense" and "Test Driven Bulldozing."
Video and Show Notes: https://youtu.be/6i8Jcvo-4BE
Ever suffered through a traditional training session? What about it made it painful? On the other hand, ever came out a learning session refreshed and ready to apply new skills? What was the game changer that really elevated the session?
Join Chris and Austin as they have a great time with Ted M. Young discussing traditional training vs. learning ensembles. Ted shares his journey through many different styles of training including his recent remote discoveries leading to learning with faster feedback and better results. Then they jump into the world of Hexagonal Architecture and Outside-In TDD. They discuss tips and tricks on not only how to teach these things but also to apply them in real production code in smaller steps.
Video and Show Notes: https://youtu.be/edwXPr5Nrno
When have you seen teams be the most effective? Standing teams? Or, just-in-time teams? Instead of forming long-lived teams around a product, a domain, or a component, what would it look like for a team to self-organize around a thin-sliced full-stack task?
Join Chris and Austin as they discuss the innovative practice of "Task Force Driven Development" (TFDD) with Steve Bishop. Come hear what happens when concepts from lean software development, domain driven design, and the mythical man month integrate in dynamic reteaming. Next, they explore the synergy of TFDD with Mob Programming and share several observations after coaching many mobs.
Video and Show Notes: https://youtu.be/7vRkiGatUNI
Is laziness in software development good or bad? How about a lack of focus? When is it good for a system to favor short attention spans? When is it not so good?
Join Chris and Austin as they have a lively discussion with Dustin Thostenson on the topic of "Clear & Simple." They first dive into learning by doing, katas, understanding others, and being understood. Then they not only explore the paradoxes involved in laziness and focus but also share about how those things tie into improving interpersonal skills via mob programming.
Video and Show Notes: https://youtu.be/izcEefyTZVw
Heard of dedicated learning time but never experienced it yourself? Curious what people actually do during this mystical time?
Join Chris and Austin as they share about what goes on in dedicated learning time. They not only give examples of some activities they have seen (e.g., solo vs. group learning), but they also share what they are doing in dedicated learning time right now. Topics also covered include learning how to learn and the interplay between production work and dedicated learning time.
FYI: Video and show notes to be posted here in the next day or so.
Heard of dedicated learning time but never experienced it yourself? Curious what people actually do during this mystical time?
Join Chris and Austin as they share about what goes on in dedicated learning time. They not only give examples of some activities they have seen (e.g., solo vs. group learning), but they also share what they are doing in dedicated learning time right now. Topics also covered include learning how to learn and the interplay between production work and dedicated learning time.
FYI: Video and show notes to be posted here in the next day or so.
If silos are problematic for technical knowledge, are they also problematic for product knowledge? Should product experimentation, decisions, and prioritization be owned by the "single wringable neck"? Or can it be owned by a team?
Join Chris and Austin as they share about "Collective Product Ownership." After they discuss the distinction between a siloed feature factory and a shared feature discovery shop, Austin shares a collective product ownership mob case study on an IoT cloud innovation. Come see how group customer interaction, group visioning, group diagramming, and group product experimentation is not only possible but also can be fun and effective.
FYI: Video and show notes to be posted in the next day or so.
If silos are problematic for technical knowledge, are they also problematic for product knowledge? Should product experimentation, decisions, and prioritization be owned by the "single wringable neck"? Or can it be owned by a team?
Join Chris and Austin as they share about "Collective Product Ownership." After they discuss the distinction between a siloed feature factory and a shared feature discovery shop, Austin shares a collective product ownership mob case study on an IoT cloud innovation. Come see how group customer interaction, group visioning, group diagramming, and group product experimentation is not only possible but also can be fun and effective.
FYI: Video and show notes to be posted in the next day or so.
"Production Deployments" …does this phrase strike fear into your soul? Or Joy? Stress or Peace? What things are conducive to dreadful delivery? What things are conducive to delightful delivery?
Join Chris and Austin as they discuss "The Joy of Continuous Delivery" with Dave Farley. Dave not only shares about the Zen of Continuous Delivery (CD) but also shares about barriers to CD, TDD/BDD & CD, small steps, and CD coaching. They also discuss Modern Software Engineering (in a hyper-agile context) and the ROI of learning organizations.
Video and Show Notes: https://youtu.be/mjoBw1utFAY
"Production Deployments" …does this phrase strike fear into your soul? Or Joy? Stress or Peace? What things are conducive to dreadful delivery? What things are conducive to delightful delivery?
Join Chris and Austin as they discuss "The Joy of Continuous Delivery" with Dave Farley. Dave not only shares about the Zen of Continuous Delivery (CD) but also shares about barriers to CD, TDD/BDD & CD, small steps, and CD coaching. They also discuss Modern Software Engineering (in a hyper-agile context) and the ROI of learning organizations.
Video and Show Notes: https://youtu.be/mjoBw1utFAY
Is Theory of Constraints and Throughput Accounting in opposition to Lean and Agile thinking? How about with Mob Programming? Or, are the relationships more synergistic?
Join Chris and Austin as worlds collide in this discussion with Daniel Doiron on "Throughput Accounting for Knowledge Work." It starts off with summaries of Theory of Constraints, Throughput Accounting, The Goal, Brown Money, and Green Money. Then they dive into Special vs. Common Causes and compare/contrast it all with Lean, Agile, Kanban, and Ensemble Programming.
FYI: Video and show notes to be posted here in the next day or so.
Is Theory of Constraints and Throughput Accounting in opposition to Lean and Agile thinking? How about with Mob Programming? Or, are the relationships more synergistic?
Join Chris and Austin as worlds collide in this discussion with Daniel Doiron on "Throughput Accounting for Knowledge Work." It starts off with summaries of Theory of Constraints, Throughput Accounting, The Goal, Brown Money, and Green Money. Then they dive into Special vs. Common Causes and compare/contrast it all with Lean, Agile, Kanban, and Ensemble Programming.
FYI: Video and show notes to be posted here in the next day or so.
What things make a career in tech unattainable for some? What would make a career in tech accessible to more people? Once someone has started their code journey, what things help a career flourish?
Join Austin and Chris as they discuss with Mike Roberts making tech careers accessible and equitable at Creating Coding Careers. Mike not only shares about the mission and results of https://cccareers.org/ but he also shares many aspects of his "playbook" for enhancing and enriching the early career of developers: e.g., Mob Programming, Apprenticeship, Mentors, Job Placement, etc.
FYI: Video and show notes to be posted here in the next day or so.
You may have heard about Mob Programming from a professional developer's perspective. But have you heard about it first hand from a college student's perspective?
Join Chris and Austin as they ask college students Jack Wei, Joel Plotnik, and Alec Arce about their ensemble experiences with other students and with professional engineers. Jack, Joel, and Alec share about what they liked and what they did not like in their weekly mobbing sessions. Lastly, as they reach the end of their college journey, they offer advice to college students who are just starting out.
FYI: Video and show notes to be posted here in the next day or so.
How did you learn to communicate well? How do you teach emotional intelligence and tact to other team members? What are ways teams can interact with others where it feels like it's coming from a team and not just an individual?
Come join Chris and Austin as they share how they write emails and learn/teach communication skills in an ensemble. Flow efficiency patterns and anti-patterns are covered. Email "refactoring" stories are shared. Come hear how collective ownership not only applies to code but also to communication, slides, and yes... GIFs!
FYI: Video and show notes to be posted here in the next day or so.
"To refactor, or not to refactor," that is the question when starting new work and before writing the first test.
Join Chris and Austin as they discuss the applicability of "Refactor, THEN... Red Green Refactor." Inspired by the Kent Beck quote "For each desired change, make the change easy (warning: this may be hard), then make the easy change," they walk though some examples of when they found it valuable to do so in TDD ensembles. On the other hand, they also discuss cases when the mob they were in decided to jump straight into "Red Green Refactor" without the refactor first. Lastly, they share their stances on refactoring when creating prototypes.
Video and show notes: https://youtu.be/ANuh_z9rUno
Is there something that could put learning into hyperdrive in your context? For example, what environment, principles, and practices could enable onboarding to occur with speed and quality?
Join Chris, Austin, and Willem Larsen as they not only share stories of "Ludicrous Speed Learning" but also discuss #EnsembleFirst as an alternative mindset and way to experiment with flow efficiency. In addition, they talk through organizational change in relation to ensemble programming, skills, and vocabulary (e.g., when to use the word "mob" vs. the word "ensemble").
Video and Show Notes: https://youtu.be/Hx9GFeXHCug
What is management? Is it simply getting people to work hard? Is it supervision? Is it extracting maximum labor and value? Or something else?
Join Chris, Austin, and Esther Derby as they not only discuss ways to rethink management but also discuss ways to nurture positive change in management, organizations, and teams.
Video and Show Notes: https://youtu.be/rr6vlDgMUws
Mob Programming turns 21? Or, is Mob Programming still pre-teen? Or, more loosely has the generic form of mobbing been around for ages under different names?
Join Chris and Austin as they discuss with Moses Hohman and Andy Slocum their 2001 Mob Odyssey. Moses and Andy not only share about Mob Programming at ThoughtWorks back in the early 2000s but also recent mobbing at Flare Health and Thoughtworks. Lastly, they discuss the side effects of mobbing, mob programming for learning vs. for work, and the differences between mobbing and pairing.
FYI: Video and show notes to be posted here in the next day or so.
What are the different styles of mob programming you have seen or experienced? Ever been in a mob that was "Fast and Furious"? An ensemble that favors autonomy first and is hyper focused on solving the problem in a more "multi-threaded" fashion with rapid cycles and lots of concurrent experimentation? On the other end of the spectrum, ever been in an ensemble that was more synchronized and peaceful? A mob that is more "single-threaded" and is optimized for consensus style decision making and learning?
Join Chris and Austin as they share about their High Octane vs. Zen Mob Programming experiences. They first share about different ends of the mob style spectrum and then offer some possible suggestions for when to use each style type. Lastly, some tips are offered on how to join a mob and thrive when they are operating in a style different than you are used to.
Video and show notes: https://youtu.be/nvKyYp-LsCk
How do you collaborate with people from disciplines like finance and legal? What collaboration patterns with inter-dependencies lead to higher availability in the system, higher responsiveness, and faster flow? What collaboration patterns lead to more waiting, more queues, more context switching, and large batches?
In response to a listener's request, join Chris and Austin as they reflect on multiple mobbing experiences with people from finance and similar disciplines.
Video and Show Notes: https://youtu.be/uTLslRUrQXQ
What methods from operations management science and manufacturing should be applied to software development? From Taylor? From Gantt? From Deming? Does operations management science thinking lead to mobbing? Does Scrum imply ensemble programming?
Join Chris and Austin as they discuss "Advanced Napkin Math, OM Science, Scrum, and Mobbing" with Steve Hallman. First they discuss the history of ideas in operations management science, scrum, and their relation to mob programming. Lastly, Steve shares about his advanced napkin math tools he uses for teams and planning in software development.
FYI: Video and show notes to be posted here in the next day or so.
When you are passionate about one of your current ideas or practices, how do you share it with others? If there are multiple competing ideas/practices for your team or org to experiment with, how do you evaluate the next best one to try?
Join Chris and Austin as they discuss "Sharing Ideas with Clarity and Delivering Value" with Tom Gilb. After they talk over each others' principles of "Just Sharing," Tom gives an overview of Planguage and Impact Estimation Tables for value delivery. Lastly, they touch on some principles from Musk's Engineering Philosophy.
Video and Show Notes: https://youtu.be/NLBzeHggcuA
Do you remember the moment when you first experienced “agile magic?” What was your experience like? If the “agile magic” has since then been lost, what can be done to bring it back? Can it be done remotely?
Join Chris and Austin as they discuss “Remotely Recapturing the Agile Magic” with Tom Ayerst. Tom not only shares about the state of remote work and agility but also shares about "evil empire agile” vs. effective agility. Lastly, they discuss the principle of making it work for everyone.
Video and Show Notes: https://youtu.be/mfSIudqjlDI
How do you have good software design? How does this scale over time? How do you have good organizations and teams? Can this scale? If so, how?
Join Chris and Austin as they discuss "Scaling Organizations and Design" with James Shore. James starts out by sharing about the Mob Programming chapter in his book The Art of Agile Development. Then they discuss scaling orgs with the FAST framework and scaling code with evolutionary design. Lastly, they talk about testing without mocks and Classicist vs. Mockist TDD.
Video and show notes: https://youtu.be/duF4e3CwW9k
As you test, are you learning? Does each test impact the design of the next test? As you test, is a group learning? Is the wisdom of the crowd continuously used to inspect and adapt the testing approach?
Join Chris and Austin as they discuss Ensemble Teaching, Exploratory Testing, and Product Development with Maaret Pyhäjärvi. She not only shares about exploratory testing before and after ensembling, but also about the synergy of visualization and exploratory testing. Lastly she shares about ensemble programming with kids, students, and women over 40.
Video and Show Notes: https://youtu.be/AjJF-0r5HMc
When seeking to learn a new programming language, what is your MO?
Join Chris and Austin as they discuss with Shahar Dawn Or who when seeking to learn Rust made his MO Mobus Operandi, that is, starting mob programming meetups to learn Rust. Streaming from Thailand, Shahar Dawn Or also kick-starts some brainstorming with Chris and Austin on a "mob for hire" concept and then they all discuss the synergy of Teal Organizations and mob programming.
Video and Show Notes: https://youtu.be/nxNDo-7Fyfk
If learning quickly is a competitive advantage, what does it mean to have a learning organization? How do you cultivate this kind of environment where you work? Has "working harder" ever made problems worse? If so, what is going on at the system level? How can we better surface, test, and improve our internal pictures of how the world works?
Join Chris and Austin as they discuss "Learning Organizations and The Fifth Discipline" where they walkthrough: - Systems Thinking - Learning and Experimentation - Vision and Mastery - Dialog and Shared Vision - Learning Organizations and Mob Programming
Video and Show Notes: https://youtu.be/U_KkTQabKXE
How do you introduce good software engineering practices to people who are new to it all? Whether it is on the job or in an academy, what do you teach first in software development? What do you teach second? How do you teach it?
Join Chris and Austin as they discuss "Learning through the Ensemble" with Clare Sudbery. We not only talk about pairs and ensembles at Made Tech Academy but we also share experiences about troubleshooting issues in new ensembles.
Video and show notes: https://youtu.be/L5hbonDKITo
Ever feel like you are drifting away from "Agile"? Do the principles of lean startup and innovation conflict with agility? Has your "experiment => inspect => adapt" cycle ever led to a good place but is not what many consider Agile?
Join Chris and Austin as they discuss "Cheating on Agile" with Anders Haugeto. They discuss Lean Startup, Innovation, and Stereotypical Agile vs. Agile Manifesto. They also dive into some concrete examples of cheating on agile in regards to time and context switching.
Video and show notes: https://youtu.be/tgRXZbJMQdI
For a team, is solo leadership the most effective? Or is collective leadership a feasible alternative? Should product responsibility be primarily a solo activity? Or fundamentally the activity of a group? With sometimes drastic differences in timing and supply chain, how can one stay lean in the complicated world of IoT products that not only have software but also have hardware and firmware?
Join Chris and Austin for another fantastic time with Mary and Tom Poppendieck. They pick up the discussion where they left off last time and revisit "Leadership and Responsible Engineers." However, this time they focus on collective vs. solo leadership and collective vs. solo responsibility. Then they dive into the "Lean Internet of Things" and techniques for healthy system integrations.
Video and show notes: https://youtu.be/9SyYPaAD1K4
How do teams collaborate at Tesla?
What does it look like to optimize for the pace of innovation?
Join Chris and Austin as they discuss "Mobbing at Tesla" with Joe Justice. Joe not only shares what mobbing on hardware looks like at Tesla but also shares why optimizing for the pace of innovation is key in this flavor of agility. Lastly, we discuss the top two questions Joe gets asked on ensemble programming.
Video and show notes: https://youtu.be/hCLNswMtk5k
What would a healthy retrospective look like if it had no facilitator? What if self-organization was applied not only to how the team works but also how they retro?
Join Chris and Austin as they discuss "Retrospectives from the Back of the Room" with Allan Kelly and Nicolas Umiastowski. Allan and Nicolas not only share about how to gamify retrospectives with dialogue sheets and cards, but also share about how to redistribute power in retros.
Video and show notes: https://youtu.be/9UwfCyp4Jyc
What is the "day in the life" like for a mob programmer at a different company? While many learn from experiments and experiences in their own company, what kind of things foster first hand learning from people in other companies?
Join Chris and Austin as they discuss "Cross Company Continuous Improvement" with Jonathan Turner and Mike Clement where all share about their Developer Visitor Programs and their recent Mobber Exchange Experiment. Lastly, they chat about what's exciting in tech right now.
Video and show notes: https://youtu.be/WKo6ToFMpVQ
Ever been in a mob that is not engaged and is just ritualistically going through the motions? Or, ever been in a team that is not really collaborating but just putting on good "Agile Theatre"?
Join Chris and Austin as they discuss with Scott Bellware the tale of two teams: The Mundane Mob & The Exquisite Ensemble. Scott not only shares stories of good vs. bad mob programming and good vs. bad XP, but he also shares about the heart of pursuing perfection in lean and its implications for high performing teams.
FYI: Video and show notes: https://youtu.be/WlcjhU-o4HQ
When it comes to software delivery, what terms do you use to describe results? Products, features, points, enhancements, specs, or requirements? Something else? Who is responsible for software delivery? Who should be? Has Agile missed the boat when it comes to responsibility and leadership?
Join Chris and Austin as they discuss "Responsible Engineers and Outcomes" with Mary and Tom Poppendieck. They walkthrough concrete examples of what it looks like for lean teams to maximize outcomes and minimize outputs. While exploring these examples, they touch on customer interaction, feedback, the responsible engineer, and the single threaded leader. You don't want to miss this episode of the Mob Mentality show with two of the biggest thought leaders in lean software development!
Video and show notes: https://youtu.be/0PsX6bAfhSI
How can you work/mob in a way where the mental, emotional, and physical well-being of people is paramount? Instead of cookie cutter solutions, how can you create an environment where space and opportunity is made for people to make the choices that are best for their unique circumstances?
Join Chris and Austin as they hear from Sheldon Nunes and Swati Swoboda from Shopify as they share about how they used mob programming to discover new ways of digitally connecting, collaborating, and building relationships. They also shared about prototyping, open team collaboration channels, and much more.
Video and and show: https://youtu.be/AyS5W28VGrs
For software development, what advice would you give that is generally true? If faced with choosing between two alternatives, what proverb more often than not is going to lead us on a good path?
Our hypothesis: "Favor Faster Feedback." Join Austin and Luis Martinez as they share at the 2022 Code Freeze Conference how this not only applies to test speed in TDD, but to almost everything in software development. Whether it is code, pipelines, product features, experiments, people, learning, or peer review, is fast feedback the path to the land of milk and honey?
Video and show notes: https://youtu.be/VHh-tM0gyBE
When a software dev team in the UK Police Force wanted to experiment with Pair and Mob Programming, what did it look like from the Product Manager’s perspective? Did the Product Manager see a difference in quality and delivery? How was the team trusted and protected? What was the impact of Agile thinking and Agile transformation?
Join Chris and Austin as they hear Scott Fulton tell his story of a "A Mob Programming Journey from a Product Manager’s Perspective."
Video and show notes: https://youtu.be/YCufE_nf87M
If one's continuous improvement cycle leads to an adoption of Mob Programming, does Scrum largely disappear? Is it a paradigm shift where one set of principles and practices is completely changed out for a new one? Or, do the same principles and practices merely show up differently? Or something in-between?
Join Chris, Austin, Ryan Ripley, and Todd Miller as they share and discuss their take on "Does Mob Programming Replace Scrum?" In addition they talk about mob programming vs. code review, continuous improvement, and pair/mob programming being exhausting vs. sustainable.
Video and Show Notes: https://youtu.be/JdpS3kXWZNI
In the mobile game development world, what does Mob Programming and TDD look like? How does an Agile mindset and DevOps thinking apply in this space?
Join Chris and Austin as they explore with Roni Jokinen the similarities and differences of Mobbing, TDD, DevOps, and Agile in mobile game dev vs. enterprise software development.
Video and show notes: https://youtu.be/tWc0EwMhTzc
You may have heard of Mob Programming. But have you heard of Mob NOT Programming?
Join Chris and Austin and they hear Scott Showalter share his story about mob programming for non-code related work. In addition, Scott shares some inspiring thoughts on growing agilists, coaching coaches, and developing team trust.
Video and Show Notes: https://youtu.be/TYbap36WGKk
What voices are heard the most in your tech community? What voices get the most platform time? What voices get the most attention? The seasoned and established? Or the new and growing?
Join Chris and Austin as they hear from Joel Norman the inspiring origin story of the Canton Coders meetup, a community founded on helping new and growing developers of all stripes. Come hear what it is like to be part of a community that favors the coder over the employer. Come hear about a meetup that helps devs of all kinds learn via warm and welcoming mob programming. Come hear about a community that really cares and helps people find good healthy jobs. Lastly, come hear Joel's elevator pitch for Mob Programming's ROI.
Video and Show Notes: https://youtu.be/UAi3EgcQkvY
Think that pull requests (PRs) are the only way to do open source? Think again! Join Chris, Austin, and Matt Wynne as they not only discuss Mob Programming on Cucumber’s Open Source but also how to do so in a way that strives for inclusivity and vulnerability. Lastly, Matt shares about the synergy between BDD/Cucumber, ensemble programming, and quality. Video and Show Notes: https://youtu.be/sERkkWQpZ4Q
If you could hand craft an ideal way to launch someone's career in tech and software development, what would it be? What would be the overall goal and how would you achieve it?
How would they learn not only full stack coding skills, but also interpersonal skills? How would they learn to overcome not only technical challenges, but team challenges? How would they land their first job?
Join Chris and Austin as they discuss "Career Launching Bootcamps via Mob Programming" with Oscar Strömsäter, Marcus Hammarberg, and Ossian Nörthen. In this episode, we hear how a mix of mob programming and solo programming is used in their bootcamps to raise up and place the next generation of excellent software developers in their first job. We hear not only what their bootcamps are like from the outside, but also from the inside, that is, from the perspective of someone going through the program. Lastly, we hear how these bootcamp teams overcome hardship together and end up loving their team.
Video and show notes: https://youtu.be/lFnMWN7XBks
Your experience of "DevOps" got you feeling down in the dumps? Does your "DevOps" seem like fractal-based development, continuous isolation, continuous deliberation, and eventual delivery? Well, you may be a SAD (Scaled Agile DevOps) practitioner and no wonder you feel like a certified SAD fellow :) Join Chris and Austin as they discuss SAD DevOps with Bryan Finster. They kick off the conversation by exploring the application of Deming quote's "A goal without a method is cruel." Then they jump into SAD DevOps, which naturally leads to an overview of Minimum Viable CD.
Video and show notes: https://youtu.be/UTfdV4CoiCo
What terms and phrases come to mind when you think of software development in a government context?
Bureaucracy, process, and silos? Solo work, heavy documentation, and large fixed plans?
However, who says a government team can't be lean and agile?
Join Chris and Austin as they discuss with Husham, Balaji, and Tim on how they used Mob Programming to onboard, level up, and deliver value to their local citizens in Texas with high flow efficiency. They not only share about how the difference felt internally after they started ensemble programming, but they also share several exciting software delivery stories (e.g. marks and brands for cattle, vaccine waitlist).
Video and show notes: https://youtu.be/Pz0J_3zSpU4
If Extreme Programming is so great, why hasn't it crossed the chasm? If TDD, refactoring, emergent design, and pairing/mobbing truly solves a whole host of problems in software development, how come more aren't doing it? Join Chris and Austin for a stimulating discussion with David Bernstein on Extreme Programming adoption challenges. In addition, David shares the benefits he has seen with XP and we discuss the relationship between coding and sound thinking. Video and show notes: https://youtu.be/3DkN2mZiz_8
While a mob programming environment has helped many grow in coding skills, what is its impact on public speaking skills? How do lightning talks and mobbing help new programmers learn the art of presentations? What happens when concepts from lean and ensemble programming are applied to public speaking? Join Chris and Austin as they hear Reinier Pamintuan's first hand experiences with learning public speaking in a mob programming environment. Rei not only shares about public speaking in lighting talks, but also in stand-ups and monthly product demonstrations. Lastly, remote presentations vs. in-person presentations are compared and contrasted. Video and show notes: https://youtu.be/fw6ZstYzmDE
Ever been on a team that "works big"? Large, prescriptive projects with no incremental value delivery, no experimentation, and infrequent integration. On the other hand, ever been on a team that traded its waterfall for a whirlpool? A team that "thinks small" and "works small." They sprint in circles. The work lacks coherence and feels scattershot. There's a perception of progress, but looking back the team sees a lot of disjointed, reactive work. Is there another way? Come join Chis and Austin as they discuss the art of "Thinking Big, Working Small, and Sense-Making Together" with John Cutler. John not only shares about shipping as fast as you learn and learning as fast as you ship but also about applying the mobbing spirit to non-code related situations. Video and show notes: https://youtu.be/LX-YzmD2Prc
Ever been in a team programming session that felt chaotic?
Ever seen people in a #MobProgramming session going in different directions?
What things help an ensemble to work together in harmony on one thing?
Join Chris and Austin as they discuss with Thomas Much tips, tricks, and tools for Mastering Focus in Team Programming Sessions. Not only does Thomas share great techniques for keeping focus in mob sessions, but he also explores the benefits of taking breaks and the positive effects of using mob programming even if part time only.
Video and show notes: https://youtu.be/FMv96zRJzAE
How can your customer value be maximized and waste minimized in product development when many “team members” work in isolation? How can wait time be reduced when work is completed in isolation and passed around for review? How can quality be built in when most development processes inherently employ post-production inspection?
Come join Chris and Austin as they transport you to the parallel universe of Mob Programming. Wait time is eliminated. Quality is truly built in with little to no bugs. Cycle time and batch size reduced. Flow efficiency maximized. Continuous kaizen and people are first in every way. In sum, lean turned up to 10.
Not only will mob programming be linked to lean principles, but many real world concrete examples will be shared stemming from 12+ years of combined mob programming experience.
Video and show notes: https://youtu.be/qjZ2_ZLorjQ
In what context was mob programming discovered? What were tech practices like before and after the discovery? What was the biggest personal challenge in the new way of working? How did the collaboration patterns change?
Who better to answer these questions than members from the original #MobProgramming team on the 10 year anniversary of the practice 🎉
Join us, DanYeung Wong, Dexter Baga, and Woody Zuill in this fun and insightful conversation as the panel takes a trip down memory lane.
Video and show notes: https://youtu.be/kYeYdU4ZRg4
How do you maximize technical learning in your team? How do you maximize social learning? Is there a way to maximize learning for both at the same time?
Come join not only the discussion on socio-technical training from the back of the room with Marco Consolaro, Alessandro Di Gioia, and Pedro Santos, but also the conversation on organizational psychotherapy, the safety of ensembling, and the book Agile Technical Practices Distilled. We really had a good time in this episode and you don't want to miss it!
Video and show notes: https://youtu.be/a8dOHS_2hTk
As a leader, how do you develop trust with your teams?
As a team member, how do you develop trust with other team members?
Imagine trying to develop trust only by talking to someone a few minutes a day/week. Now imagine the parallel universe of Mob Programming where servants leaders/coaches work side-by-side with their teams for hours daily. Misunderstandings fade away. Empathy and trust grow rapidly.
Join us to not only see it described but also to see mobbing demonstrated live with a real team.
Video and show notes: https://youtu.be/pUaiDxX_rv8
What do you think the future of product development is going to be? How about software development? If the good things you are currently experiencing are turned up to 100 in the future, what would that look like? Join Chris and Austin as they not only share their past and present of product/software development, but speculate about the future in regards to team, code, design, quality, and interpersonal growth. Video and show notes: https://youtu.be/wyXWAN-txNk
Ever been on a team that had great agile habits from a non-technical perspective but lacked craftsmanship? What was it like? How about the other side of the coin? Ever been on a team that had technical excellence but lacked agility in regards to process, product, etc.?
Now imagine a world where these powers are combined. Join Chris and Austin as they discuss with Nicolas Umiastowski and Cedric Martin how they crossed the chasm between agile and craftsmanship with tag team coaching and mob programming.
Video and show notes: https://youtu.be/P_SwQAfG2-4
Is mob programming disastrous for introverts? Does it inevitably lead to exhaustion? Does it pit introverts and extroverts against each other? Does ensemble programming naturally lead to loud extroverts dominating the flow?
Come join two introverts (Matthew Killoran and Aaron Griffith) and two extroverts (Chris and Austin) as they discuss introverts and extroverts in Mob Programming. All four have been doing mob programming full time for many years and in this episode they hit topics like the "Both Stretch" model and the "Silent Sr" model. Lastly, they discuss the "28 seconds of silence" experiment and run it live on the show! Yes, the "28 seconds of silence" experiment was hard for the extroverts, but it was good for them :)
Show notes and video: https://youtu.be/Li-_fnDYkBk
What is the cost of your development team making an estimate? Is the cost simply the time it takes to make it (e.g. in planning poker)? Or, are there any second order costs as well? For your estimates, what are the side effects of the side effects?
Join Chris and Austin as they discuss what many organizations have paid for their estimates. After experience in being on teams that estimate and experience in being on teams that do not estimate, they discuss costs such as:
- 80/20 Rule * Cost of Delay
- Design Trade-offs
- Estimation Creation Time
- Parkinson's Law
- Cost of poor security and data protection
Video and show notes: https://youtu.be/ejm1_p0YsT4
If someone asked you for blind advice, what would you say? What is your helpful hipshot? No need for it to be a universal law. However, it should at least be something that is generally good guidance in most situations whether it is tech, code, people, business, or process.
Derived from his many years of experience and geekery, GeePaw Hill's blind advice is "Take Many More Much Smaller Steps." Join Chris and Austin as they explore with GeePaw the meaning and application of this wisdom. Lastly, we discuss the principle "The Code Works for You, You Don't Work for the Code."
Video and show notes: https://youtu.be/lHoOUylvfxQ
What was your college computer science experience like? Did it have helpful levels of collaboration and teamwork? Were you able to learn from other students? Or was it mostly divide and conquer in isolation? What would it be like if a computer science course were designed to not only teach you how to code but also how to have healthy collaboration, vulnerability, kindness, consideration, and respect?
Join Chris and Austin as they discuss with their former professor Youwen Ouyang about her past and current applications of #MobProgramming in Intro Comp-Sci Courses where she shares challenges, strategies, and benefits of this approach.
Video and Show Notes: https://youtu.be/CFwjz3TZe-E
While mob programming, how do you verbalize pain? How do you express joy? When do you amplify pain in the mob and show empathy? When do you recognize happiness and encourage it to take center stage? Why call for a retrospective on a pain point? Why inspect and adapt to turn up the good?
Join Chris and Austin as they share about the new Mob Programming Roles "Major Pain" and "Dr. Feel Good." They not only give some examples of how to take on these roles in your mob, but also share some stories of people who embraced these roles in the spirit of continuous improvement to take their team to the next level.
Video and show notes: https://youtu.be/BfsxfEDn9q4
How do you keep engagement and productivity high in your interactions? Whether the conversation is about code in a mob programming session, market experiments in a story mapping session, or what is good and true, how do you amplify psychological safety, constructive radical candor, and learning? What things drive the interaction towards a consistent shared mental model and towards discovering the next best experiment to run?
Join Chris and Austin as they discuss Socratic Learning and Tech Optimized Interpersonal Interactions with Michael Strong. They not only explore non-tech techniques for these crucial conversations but also share about some tech tools that have helped many optimize their interpersonal interactions. In addition, they touch on some agile/holacracy management concepts and their application to creating a healthy learning environment for large groups.
Video and show notes: https://youtu.be/dOG9nqX4Vow
When you enter a legacy code base, where do you start? How do you analyze the code? How do you set it up for safe changes? How do you know when to stop cleaning? Join Chris and Austin as they not only discuss legacy code refactoring and mending with M. Scott Ford from Corgibytes, but also share some analogies for code technical health and safety. Video and show notes: https://youtu.be/2ay2kQu6PZw
How do you prefer to learn? Do you prefer to run some experiments first and then later get guidance? Alternatively, do you prefer to first have someone with expertise model and guide you? Are there situations where one method is more effective than the other? Join Chris and Austin as they share about different models of teaching and learning they have seen work well in Mob Programming including the "I do, we do, you do" model and the "You do, (and if needed, we do)" model. Video and show notes: https://youtu.be/ygImu9e9O68
Often in mob programming great facilitators emerge. They rise to the occasion to help each team member learn and contribute. Now imagine a learning context where the great facilitator that emerged was AI. A conversational agent skilled and trained in sponsorship and mob roles. An AI facilitator that not only helps to keep the mob code flowing but also helps students work through conflicting ideas, collaborate, and retrospect. Instead of the usual "divide and conquer" seen in group projects, students build a shared mental model together and truly work together. Join Chris and Austin as they discuss the implementation of these "AI Enabled Mobs for Learning" with Carolyn Rosé from Carnegie Mellon University.
Video and show notes: https://youtu.be/LpbtwxxhTlQ
What is your coaching method? Does it change how your developers write code everyday? Does it increase agility in your software development organization?
Join Chris and Austin as they discuss the Samman Technical Coaching Method with Emily Bache. Emily not only shares about her book on this topic but also about the coach role in an ensemble and persuading teams to get coaching and to try ensemble working.
Video and show notes: https://youtu.be/cU8_tqW0tnc
How do you interview candidates? Do you ask them about their views on code, collaboration, and agility? Do you check their ability to recite facts related to the work and industry? Do you ask them behavioral questions about their past or about hypothetical situations?
Come join Chris and Austin as they transport you to a parallel universe for interviews. A universe where instead of talking about code and collaboration in an interview, the candidate actually collaborates on code with the team via Mob Programming. Instead of you hearing how they think they would act, see how the candidate actually acts. You not only see how they go about code implementation, but also refactoring, testing, interpersonal interaction, problem solving, learning, coaching, and design.
In addition, the candidate gets to know by experience what "a day in the life" is like in one of your teams to see if it is their cup of tea.
Video and show notes: https://youtu.be/CJwtj9abK0o
Do your UX designers, UI designers, front-end developers, and back-end developers work as a team? Or individual silos?
LeanUX may have removed some waste but #MobProgramming breaks down the interpersonal barriers to achieve true collaboration.
Misunderstandings fade away. Empathy grows rapidly. The customer receives the fully realized product vision born of a real cross-team effort. We have seen this style of work increase flow, delivered value, and market experimentation.
Join Austin Chadwick and Gary Saunders as they present on the pros and cons of mobbing with UX designers at the "Experience Design With Agile & Lean UX" meetup.
Video and show notes: https://youtu.be/47Iae0X9D8w
Join Chris and Austin as they discuss with Jenny Carlston about finding mutual understanding, mobbing, diversity, Wardley Mapping, wisecrowding, collaborative decisioning, and to top it off, Lean and learner's mindset.
Video and show notes: https://youtu.be/N0ZIrCPPnic
"Never had a PR over 300 LoC that didn't look good to me". We've all been there. The PR is so big you don't even bother commenting. It's already too late to build the quality in. You make a sad face, comment "LGTM", and click approve.
That's still the case in lots of teams. However, it feels like after a long time the industry, on average, learned the value of the Small Batches idea from #Lean applied it to PRs.
But, here's the surprise.
What if we told you that teams doing small PRs (with async code reviews) actually have way lower throughput than teams doing big PRs.
Join Chris and Austin as they discuss with Dragan Stepanovic the insights on throughput, engagement, and quality of PRs that he has gathered from analyzing the data in 30+ active repositories. In addition, we chat about the parallel universe of ways of working where you get to have your cake and eat it too. Where you can have both throughput and quality. That universe is called co-creation patterns (Pair and Mob Programming).
Video and show notes: https://youtu.be/f9L47wT5rZk
What if lean, agile, and flow efficiency were not only applied to your product development, but also to leadership decisions? Are there practices that would lead to less wait time and higher throughput for decisions? What is the impact of a unifying goal and increased collaboration (e.g. something like mobbing in management)?
Join Chris and Austin as they discuss these intriguing questions with Johanna Rothman. In addition, they explore topics like management in agile organizations, a system of work that works, and a path to self-management.
Video and show notes: https://youtu.be/n74s-BBjPMc
How do you end up with legacy code? How come things don't go as planned? Is it as simple as one bad process/practice? Bad tech? Bad people? Conway’s Law describes how team structure influences software structure. But, does software structure also influence team structure? Is there a bidirectional feedback loop between people and code? Join Chris and Austin as they discuss with Michael Feathers about how we can learn to better see our sociotechnical systems and factor that into our decision-making. In addition we talk about the dynamics of team/org sizing and specialization. Lastly we talk about the impact of Mob Programming on a system and the role of an architect.
Video and show notes: https://youtu.be/AC4ZvN6riPE
Join Chris and Austin as they discuss with Elena Rosheva and David Legge from Red Gate Software about early hurdles of #MobProgramming, mobbing on everything, and striving for remote mob zen.
Video and show notes: https://youtu.be/vDjT4QPT7us
"All the brilliant K-12 students working on the same thing... at the same time... in the same space... on the same computer..."
How are you raising up the next generation of developers? Is there a way to teach kids programming that is less like a "sage on the stage" and more like a "guide on the side"?
Join Chris and Austin as they discuss with #educators Jeanine Rioux and David Coopersmith how they have used collaborative coding techniques like #MobProgramming to teach CompSci for K-12 students. They not only share how they code with the kids in the classroom but also about how they set up annual #MobProgramming experiences for their students with Chris, Austin, and other professional engineers. Lastly, they discuss how they help themselves and other teachers pursue the goal of being life-long learners.
Video and show notes: https://youtu.be/hnKRX0SV7cM
What is the way you solve a tough problem? Regardless if it is related to code, tech, people, or process, is the best approach to relentlessly keep working at it with all your will and might? Or is there another way that is less exhausting?
In regards to change initiatives, do you truly have #empathy and understanding for so-called "laggards" in the diffusion of innovation curve? Is there a concrete way to build it?
Join Chris and Austin as they discuss with and are inspired by Linda Rising.
Video and show notes: https://youtu.be/SW736CjNMjY
What if we thought about our conversations like a unit test in Test Driven Development (TDD). Not in the sense of treating people like computers and being robotic but in the sense of failing fast and correcting fast... in the sense of having a test in place to verify understanding and context before taking the next small step in the conversation. Would we avoid big batch conversations full of misunderstandings? Would we catch errors in conversation before they compound into production defects? Join Chris and Austin as they discuss with Mark Holmes about "TDD for people" as well as micro-retrospectives and experimentation.
Video and show notes: https://youtu.be/BexHm0TD6gM
How quickly do Jr. developers onboard and "come up to speed" on your team? Are they learning and collaborating with the team on day #1? Do they feel part of the team immediately? Do they feel like they are interrupting someone else's work flow when they ask questions? Is their fresh perspective being heard to safely contribute to the code base? Join Chris and Austin as they discuss with Ben Holmes how he not only kick-started a job as a Jr. dev via Mob Programming, but also a career. On top of that, they discuss cross-discipline collaboration with PMs and designers. Video and show notes: https://youtu.be/EmNY26J3ruM
If your team replaced all of its members over time, is your team functionally the same? What mindset and practices keep your team happy and high performing even through change? If team change is inevitable, how can you be good at it?
Join Chris and Austin as they discuss the Ship of Theseus analogy applied to teams.
Video and show notes: https://youtu.be/hV_WhqRJgRE
Are your teams truly cohesive? Or just a loose association of individuals? Does your team problem solve from a shared context? Or work in isolation but shallowly sync up on occasion? Is onboarding and building social capital a breeze? Or a long-drawn-out endeavor? If interested in the former, who better to hear it from than a whole mob programming team from South Africa that has lived it. Join Chris and Austin as they discuss these topics and more with Jacques Blom, David Chaplin, and Dean Gracey from the company Names & Faces.
Video and show notes: https://youtu.be/aQej3Tnfeog
Does your flavor of #agility have the all proper seasoning to last? Does it include all the necessary facets to thrive? Does it have the proper time frames in mind to match the business goals? Do you have metaphors and analogies that really resonate with your org's domain? Join Chris and Austin as we have a fantastic discussion with Kyle Griffin (https://www.linkedin.com/in/kyle-aretae/) on these topics and more (e.g. militant humility, Extreme Programming, learning).
Video and show notes: https://youtu.be/-5ef6e0REo4
1.) People can estimate well what they have done many times before. 2.) Software developers automate what is repetitive or time consuming. 3.) To estimate something well one must have repeated it many times before and not automated it. 4.) Why would a software developer not automate something repeated many times before? Join Chris and Austin as they discuss and grapple with this paradox. Video and show notes: https://youtu.be/woF8lkhxKgc
Want to reduce the cognitive load and setup time for first time mobbers? Want to learn some tips, tricks, and tools for remote training? Want to establish a safe place in your org for effective learning and coaching? Come join Chris and Austin as they discuss these topics and more with Michael Migliacio (https://www.linkedin.com/in/michael-migliacio/).
Video and show notes: https://youtu.be/WtyYzcRrWD0
Is #MobProgramming just burning money? How could it possibly be efficient? What does Mob Programming look like in a #Scrum context? Join Chris and Austin as they discuss these questions and more with Dan Puckett. Dan has not only introduced Mob Programming to numerous Scrum teams via invitation and experimentation but he has done so in a consistent way each time with specific measurements. Come hear the fascinating results from these various experiments. Video and show notes: https://youtu.be/h-baijxbBYs
Kind candor including giving and receiving feedback is arguably one of the most important aspects of high performing teams. However giving this feedback is one of the most difficult things to do for many. It is a lot to expect from people in an organization where new relationships are being formed all the time and psychological safety can be fragile. In response to this challenge, a safe peer driven system was co-created by several mobbing teams. Come join Chris and Austin as they share the experiences and results from experimenting with this system for several years.
Video and show notes: https://youtu.be/21WTPhe3jSo
When it comes to remote mobbing or pairing with strangers, many challenges present themselves. If I allow a remote Anydesk session into my already setup home computer, how can I know they are not going to hack me? Does my home network have sufficient upload time for everyone to prevent significant lag? If I do git handover, how can I quickly get each person's computer installed with all the required development and mobbing tools? Come join Chris and Austin as they discuss with two seasoned mobbers (Llewellyn Falco and Jay Bazuzi) their novel cloud solution to this problem. You not only are going to get some excellent tech tips and tricks for remote mobbing with strangers, but also some facilitation wisdom. You don't want to miss this cloud mobbing show and tell!
Video and show notes: https://youtu.be/vB0rF0ElOT8
Imagine a team of 30-150 people that turned up the dial on self-organization to the max. Instead of favoring top-down closed allocation, they embraced open-allocation and autonomy. Now also imagine that many of these people happen to love #PairProgramming and #MobProgramming. What would their product development look like? Join Chris and Austin as they discuss with Ron Quartel the tale of two teams who independently took this vision and made it a reality.
Video and show notes: https://youtu.be/wr2UWSEykrE
What is the future of automation and AI? Is it going to look more like Star Trek with Spock? Or Terminator with Skynet? Join Chris and Austin as they discuss with Matthew Killoran about these topics as well as #MobProgramming and Automation Tips & Tricks.
Video and show notes: https://youtu.be/7NTCBv3zB3c
Do you desire to collaborate and help others but feel like the system you are working in rewards the opposite behavior? What if a promotion system were created to be peer driven and incentivize learning, contributing, domain/tech mastery, helping others, and coaching? Join Chris and Austin as they discuss the radical Peer Promotion Process they have been working in for many years. Come hear stories that highlight the pros and cons of this approach. Video and show notes: https://youtu.be/9jtzKfQS7Ps
What if joy was made the explicit purpose of a company? What if people were excited to come to work everyday? What if fear and suffering were removed from the workplace? What would the impact be on the business, the bottom line, and the outcomes? Join Chris and Austin as they discuss the business value of joy with Rich Sheridan. Rich is the CEO and Chief Storyteller at Menlo Innovations, a speaker, and author of Chief Joy Officer and Joy, Inc. We not only discuss with Rich joy in the workplace but also running experiments and ending human suffering in the world as it relates to technology and teams.
Video and show notes: https://youtu.be/w0xEGN6rZ04
"#Agile" in many ways has been corrupted by rote processes, rules, and coercion. Is the same thing happening to #MobProgramming? Can #MobProgramming be taught with a handbook of rules, patterns, and formulas? Or is it only caught? Is the only rule "there are no rules"? How can one share their Mob Programming leanings and discoveries in a way that does not sound like formulas? What is the right mindset in learning anything from others? Come join Austin and Chris as they discuss these intriguing topics and more with Allen Holub and Rob Williams.
Video and show notes: https://youtu.be/8EGPI5eNOIA
Undoubtedly the pandemic has caused us all to make adjustments to at least "get by". However, is there more than adapting to "survive"? How about adapting to "thrive"? Come join Chris and Austin as they discuss with Christopher Gallivan and James Simon who share the inspiring story of several teams adapting to a Global Pandemic with #Collaboration, #Community, and #Joy. In addition, they share about the insights they gained from #MobPrograming with Woody Zuill and how they are striving to build the developer community. Listen and come join in on the joy! Video and show notes: https://youtu.be/KxHdQIShh0k
In a day when many prescribe teams/orgs to follow a process by rote, how refreshing it is to hear Dave Nicolette say "I'm not here to 'implement Agile' but to solve problems." Join Chris and Austin as they discuss with Dave how he has helped many teams in large organizations solve problems and get results. He shares how in many cases the results came quickly just by helping them to collaborate and communicate well via #MobProgramming and other means. Lastly, Dave talks to the importance of testability and how a COBOL TDD framework was developed. You don't want to miss this episode of the Mob Mentality Show!
Video and show notes: https://youtu.be/KkH26s59RVE
What if there was a place where all the events and trainings were done via #MobProgramming? What if you could sign up to learn from top technologists like Llewellyn Falco, James Grenning, Ken Pugh, J. B. Rainsberger, David Bernstein, Jon Reid, Amitai Schleier, Dustin Thostenson, Skylar Watson, or Lee Barnes? Look no further since PubMob.com is here! Join Austin and Thomas in this episode of the Mob Mentality Show as they discuss PubMob with Jeff Langr and also hit exciting topics like remote tools and "#PairProgramming vs. #MobProgramming". Video and show notes: https://youtu.be/AagiPPP7zgg
Are practices like swarming and mob programming just burning money? Or, do they possibly make financial sense and have a return on investment? Are there ways to translate the benefits into the economic vocabulary of executives? Tune into this episode and you are not only going to hear an intriguing discussion Chris and Austin have with Steve Tendon (https://twitter.com/tendon) on the economies of Swarming & Mobbing, but also you are going to hear some inspiring stories on the The Power of Co-creation and The Unity of Purpose Pattern.
Video and show notes: https://youtu.be/B_KWyptanAM
Chris and Austin have a fantastic time with Alex Barry (https://twitter.com/mrozbarry) discussing his distributed #MobProgramming timer app https://mobti.me/, mobbing with new people, and tmate+vim for seamless group programming. Good times and great insights! Video and show notes: https://youtu.be/2RChhW941CQ
Ever been in a class or training and felt that the pace was going too fast for you? Or going too slow for you? In what ways does mobbing solve many of the problems inherent in traditional classroom dynamics? How is mobbing new in education yet at the same time a throwback to a more classical method of education? How is mobbing transforming education? How is it changing science education and research? What does mobbing mean for lifelong learning? Come join this intriguing and eye-opening discussion that Chris and Austin have with Nick Del Grosso (https://www.linkedin.com/in/nick-del-grosso/). Whether you are in tech, education, agile, or science, you don't want to miss this episode of the Mob Mentality Show.
Video and show notes: https://youtu.be/FwQLjEeLXl0
If all you have is a one-size-fits-all "Agile Hammer," then everything looks like a nail! Alternatively, is there a way to find a level of #Agile Fluency that best fits the business’ needs? What impact does #EnsembleProgramming or #MobProgramming have in the "Delivering" zone of #AgileFluency? What is the role of #Retrospectives in #EnsembleProgramming and #AgileFluency? Chris and Austin discuss these exciting topics and more with Diana Larsen (https://twitter.com/DianaOfPortland) in this episode of the Mob Mentality Show.
Video and show notes: https://youtu.be/Lmx5Zd_SARE
Mobs of #TDD ZOMBIES? Have no fear for James Grenning is here to save the day! Join Chris and Austin as they chat with James (https://twitter.com/jwgrenning) about some fantastic topics including TDD, ZOMBIES, embedded, and self-paced training. Video and show notes: https://youtu.be/nUys5Y-7Wms
If #ExtremeProgramming practitioners saw tremendous benefits of "n = 2 programming" (AKA #PairProgramming), what are the effects of "tuning up the good" and doing "n > 2 Programming" (#MobProgramming)? How does it compare with programming in isolation? Come join Chris and Austin as they discuss with J. B. Rainsberger his early and recent experiences with "n > 2 Programming." Lastly, J. B. gives his take on time boxing and habits.
Video and show notes: https://youtu.be/enjDX0zWS_4
Ever struggled with how to introduce a new practice like Mob Programming with your team? Looking for kind and thoughtful ways to break the ice? Join Chris and Austin as they discuss with Alex Bird on patterns for introducing mobbing with team members. Alex not only shares ways that have worked well for him, but he also shares how to do so in a way that shows empathy and understanding. Video and show notes: https://youtu.be/jLk-mRBF4NY
What does it look like when agility and systems thinking is applied beyond tech? Are our organizations and development teams really oriented towards value or do we just simply output things? Does the "Product Owner" title really describe the right goal of this role? Or should the title be changed to "Value Owner"? Come join Austin and Chris in a discussion with Colleen Kirtland as we venture beyond the "what" and "how" of product development and jump into the "why."
Video and show notes: https://youtu.be/fUv6P_KB4-M
Heard of mob programming talked about but have not seen it in action? Check out this special episode of the Mob Mentality show where we do some live #remote #mobprogramming at Agile Open SoCal 2020. Come see five devs who have not mobbed together before (Nestor Valenzuela, Kenny Jacobson, Art Bergquist, Paul Moore, and Joseph Ishak) tackling FizzBuzz in Python. Video and show notes: https://youtu.be/JeLKTvkGLNQ
If team change is inevitable, how can we get good at it? What are the pros and cons of team change? Should we encourage team change? Should we ensure it happens at a certain frequency? Chris and Austin discuss these questions and more with Heidi Helfand in light of her book on Dynamic Reteaming and her work on Sustainable Pace.
Video and show notes: https://youtu.be/wBoUGfiBlvk
MobProgramming patterns like strict driver/navigator with a timer works really well for many teams and contexts, but is there a style of mobbing that is more loose but still effective collaboration? Join Chris and Austin as they discuss Freestyle #MobProgramming with Jen Diamond. We also talk about her experiences with mobbing to learn and mobbing for work.
Video and show notes: https://youtu.be/hdzAvcz-_Mo
Ever seen someone afraid of the implications of #Agility and #MobProgramming for management roles? Or just afraid in general? Its not Halloween yet but there is quite a bit of fear out there. Come join the conversation Chris and Austin have with Thomas Cagley on: - Promiscuous #MobProgramming - #MobProgramming & Fear - #Agile & Contracts
Video and show notes: https://youtu.be/ERG9FgHQJZE
Is there a form of #AgilePlanning that is leaner than #Sprint planning? What can #AgilePlanning look like for a team doing #MobProgramming? Come hear Chris and Austin share how product planning has worked for the #MobProgramming teams they have been on and how it has been dramatically different from not only waterfall but common #Agile frameworks like #Scrum. Video and show notes: https://youtu.be/iYreavnXE-o
Ever seen a team take some training to only watch them never really try or apply in real work what they learned? Been there yourself? Come join the conversation Chris and Austin have with Camille Bell as she shares about Mob Programming to make training stick, teaching agile technical skills, and team building. She not only shares about what has worked well in her experiences but also what has not worked well. You don't want to miss it! :)
Video and show notes: https://youtu.be/2UhfeYr62Jc
After spending multiple years doing full-time in-person mob programming, Sandra Spaeth (https://twitter.com/SandraSpaeth) had to switch to full-time remote mob programming. Now with half a year of remote mobbing under her belt, Sandra reflects on her experiences with Chris and Austin. What are the pros & cons of remote work vs. on-site work? Is one better than the other? With something so high in interpersonal interaction like mob programming, is it even possible for remote to be as good as in-person? Come join the discussion and also pick up some tips, tricks, and experiments to try for the remote life. Video and show notes: https://youtu.be/u-VnZ-3qziI
Without a command and control leader calling the shots, what are some good ways for teams to make decisions? When people disagree while #MobProgramming, how is the path forward selected? If there is room for improvement in the decisions a team is making, how can you help them improve without making the decisions for them? Chris and Austin discuss these questions and more in this installment of the Mob Mentality Show! Video and show notes: https://youtu.be/C-iHT0xMnW0
Chris and Austin have a stimulating discussion with Allen Holub (https://twitter.com/allenholub) hitting a range of topics including Mob Programming in-person vs. remote, Agile vs. Agility, organizational change, and Scrum, SAFE, & certs, oh my! Video and shows notes: https://youtu.be/nLUFPHUS2Pk
Join a fun and insightful conversation that Chris and Austin have with Lisa Crispin on ensemble testing, mob testing, ensemble/mob programming, and agile testing. In addition to sharing success stories, we discuss challenges to collaboration and experiments to run to try to overcome it. Video and show notes: https://youtu.be/FIQcq5l1LHA
Chris and Austin discuss second order effects in systems thinking and the dramatic impact it has on product development and mob programming. Every person in a system who makes a decision has a desired positive effect. However, what are the side effects of that effect and what are the side effects of the side effects? Are they negative or positive? Experiences and suggestions are shared in regards to the second order effects of "efficient" code reviews, sprints, metrics, estimates, working solo, etc.
Video and show notes: https://youtu.be/AmoeA_Hz5Rg
Chris and Austin have an engaging discussion on all things Domain Driven Design (DDD) and Mob Programming with Pluralsight author Julie Lerman (https://twitter.com/julielerman). Topics include mob programming DDD, DDD collaboration, and mob programming legacy code.
Video and show notes: https://youtu.be/k59-OS5OqHg
Chris and Austin discussed mob programming at scale, agile, extreme programming, and "eye-opening experiences" with Andy Graham (https://twitter.com/virtualmackem) and Sean Cowan (https://twitter.com/stcowan). Video and show notes: https://youtu.be/El47KJiGnSU
Chris and Austin share how they have used the "My Turn is for Learning" mob programming pattern to not only make progress and deliver valuable work but also help someone learn who is new to the team/code/domain.
Video and show notes: https://youtu.be/Pt35EGfnugk
Chris and Austin have an exciting conversation about the past, present, and future of "MobRetreats" with Bob Allen (https://twitter.com/CuriousAgilist) and Dimitry Polivaev (https://twitter.com/dimitrypolivaev). We cover how MobRetreats came to be, what MobRetreats are, the "Global Day Of MobRetreat" event on 7/18, and the Global Liquid Mob event.
Video and show notes: https://youtu.be/Oq2Kb09o38I https://mobretreat.org/ https://global-liquid-mob.github.io/
Chris and Austin have a good time discussing with Florian Schneider (https://twitter.com/f2_107) and John Fletcher (https://twitter.com/fletchgqc) on Team Oriented Development, Pair/Mob Programming, Parallel Programming, and Chaos Engineering (Tech & Teams). Listen in and then come join the conversation! Video and show notes: https://youtu.be/WC4jznbggD8
Think mob programming and craftsmanship at a startup is a walking contradiction? Think again! Check out Chris and Austin's discussion with Mike LaRocca where they discover insights on mob programming at a startup, balancing individual & group time, and remote mob programming tools. Video and show notes: https://youtu.be/6w8lu3OgW7Y
Often the focus with organizational change is how to get teams to experiment with and adopt new practices. However, last week's well-motivated working agreement can become this month's bureaucracy that is weighing down the system. Does your org/team have a way to identify failed experiments? Does it have a way to stop them before the disease spreads? Tune in to hear Chris and Austin share their experiences with getting bad practices to leave the system.
Video and show notes: https://youtu.be/i7OxfukholY
Chris and Austin chat with David Bishop (https://www.linkedin.com/in/davidbishop/) about mob programming embedded systems, his Metagility framework, and agile in embedded systems development.
Video and show notes: https://youtu.be/fiLR36Y67rM
Chris and Austin discuss with Dana and Bryan Finster who share a story about how they used mobbing to keep CD running in a suddenly remote environment. Further into the discussion, we discover the synergistic relationship between mob programming and continuous delivery.
Video and show notes: https://youtu.be/K2UBYNx01PM
Chris and Austin talk with Harald Reingruber (https://twitter.com/Harald3DCV) about his exciting remote mob/pair-programming Tour. Harald explains his preparations for the tour and also shares lessons learned from paring/mobbing with 10+ different devs over the span of 3 months.
Video and show notes: https://youtu.be/CvkeUcAAFi4
Chris and Austin share about some remote mob programming patterns they have recently discovered including Bandwidth Backoff, Remote Edge of the Mob, Designated Driver, Walk-and-Talk, and The Check-In. Video and show notes: https://youtu.be/Hy9O9VABeXs
Chris and Austin celebrate the one year anniversary of The Mob Mentality Show with Woody Zuill (https://twitter.com/WoodyZuill) and discuss the essence of Mob Programming. Some including Austin have been confused about what people mean exactly when they say "Mob Programming?" Is it a set of practices? A set of values/principles? Something deeper? Something simpler? All of the above? Come join the discussion to find out! Video and show notes: https://youtu.be/OzGlpwPNv0Q
Chris and Austin discuss "Facilitating Effective Remote Meetings" with Lynn Langit (https://twitter.com/lynnlangit), Paul Tevis (https://twitter.com/vigemus), Jason Kerney (https://twitter.com/JasonKerney), and Woody Zuill (https://twitter.com/WoodyZuill) using a lean coffee format (https://trello.com/c/zPLZ3YFq/128-lean-coffee). Topics in the lean coffee include "Ada roles," "why have meetings," "what is wrong with having meetings," "3 goal agenda," and "the importance of side conversations." Video and show notes: https://youtu.be/xr0STSbJ3PE
Chris and Austin discuss some etiquette for remote mob programming including expedition behavior, handling accidents, and virtues (e.g. kindness, sense of humor). Video and show notes: https://youtu.be/67ym9T28blM
Chris and Austin discuss with Zachary Wallace (https://twitter.com/epipenposse) on how agile led him to experiment and on part-time vs. full-time mob programming (e.g. does full-time mobbing fall into the trap of "Herd Mentality"?). Video and show notes: https://youtu.be/OvOGPZaR8GI
Chris and Austin share about tools that have been helpful in their transition to full-time remote mob programming. Video and show notes: https://youtu.be/-ZFYzpbxiLY
Chris discusses with Fred Zuill (https://www.linkedin.com/in/fredzuill/) and Kelly Gaines (https://twitter.com/runkellyg) about their continuous retro experiment that was ran in their mob. A real-life turn-up-the-good bell curve. And the winning "good" is... ??? (Spoiler: everyone-needed-is-there) Video and show notes: https://youtu.be/Lxt05CbsoGk
Chris and Austin discuss various topics with Greg Eisenberg (https://www.linkedin.com/in/gregoryeisenberg/) including mob programming and traditional job titles, mob testing, teams who selectively mob, mobbing pairing, and mob leadership. Video and show notes: https://youtu.be/-4NHyNCZV64
Chris and Austin discuss how to help teams progress well through Tuckman's stages of group development: “Forming, Storming, Norming, & Performing.” Video and show notes: https://youtu.be/XTMPJ4GD-8Y
Chris and Austin discuss the Virtuous Loop: how Dedicated Learning Time and Retrospectives have worked together to turn up the good and create product development joy for them. Video and show notes: https://youtu.be/D1ZIJ-QAwMw
Chris and Austin discuss with Jason Kerney (https://twitter.com/JasonKerney) about prosperous metrics, onboarding new team members, and psychological safety. Video and show notes: https://youtu.be/FkuiLRBhbaI
We discuss with Llewellyn Falco (https://twitter.com/llewellynfalco) about mob facilitation tips & tricks and the return on investment from mob programming. Video and show notes: https://youtu.be/uBrnlDtxRcQ
Many have found themselves unexpectedly working remote and the same goes for the Mob Mentality Show. We are "on" the same couch this episode with two experienced remote devs, Jason Weimann (https://www.youtube.com/channel/UCX_b3NNQN5bzExm-22-NVVg) and Jason Storey (https://www.youtube.com/user/charlesamat), but everyone is remote! Come join the discussion and hear some great tips & tricks on the remote life. Video and show notes: https://youtu.be/2a5O5kfzJX0