7 habits of highly effective mobber
- Inspired by Turn the Ship Around! by L. David Marquet, a book that applies leadership and responsibility principles in real-world contexts.
- Covey’s habit serves as a foundation for improving teamwork and fostering agility.
Proactiveness in Mob Programming
2. Contextual Foundation
-
Chris Lucian and Austin Chadwick explore the principle of “Be Proactive” from The 7 Habits of Highly Effective People by Stephen Covey.
- Objective: Relate this principle to mob programming and software development practices.
-
Background on the Book and Habit:
- Covey emphasizes self-determination and the freedom to choose one’s response to external stimuli.
- “Proactive people focus on what they can do and influence, rather than what they cannot control.”
Examples from Life:
- Negative Situations:
- Prisoners in a war camp finding ways to maintain hope and dignity.
- Software developers assigned a repetitive, frustrating task choosing to streamline it through automation instead of complaining.
- Positive Situations Gone Wrong:
- Someone in a supportive environment still finds dissatisfaction because of a reactive mindset, leading to missed opportunities.
Example in Software: A team faced with a chaotic legacy system might either complain about its complexity (reactive) or start identifying areas for incremental refactoring (proactive).
Proactiveness in Mob Programming
- Definition and Clarification:
- Proactiveness isn’t about merely “working harder” or preparing extensively. It’s about actively influencing situations and choosing responses.
- Why It Works in Mob Programming:
- In mob programming, multiple perspectives can challenge a reactive mindset.
- Collaboration fosters a culture where small, proactive actions (e.g., suggesting improvements during a discussion) ripple through the team.
Example in Mob Programming:
- A team encountering a recurring bug doesn’t just fix it repeatedly. Instead, they collectively brainstorm a long-term solution, such as creating automated tests to catch the issue earlier.
Real-World Examples in Development Teams
- Solo Development vs. Mob Development:
- Solo developers might feel stuck in “reactive” roles, focusing only on assigned tasks (e.g., fixing bugs or handling tickets).
- In mob development, a proactive team member can guide others toward innovative solutions or improvements.
Scenario 1:
- A junior developer is tasked with resolving bugs in a legacy system.
- Reactive approach: Fix the bug, move to the next ticket, and complain about outdated code.
- Proactive approach: Analyze the root cause, suggest improvements to reduce future bugs, and advocate for modernization efforts in team meetings.
Scenario 2:
- A team relies on a cumbersome ticketing system that slows down collaboration with another team.
- Reactive: Accept the inefficiency and blame the system.
- Proactive: One member walks over to the other team’s space, initiates direct communication, and finds faster ways to resolve issues.
Psychological and Practical Impacts
- Therapeutic Effects of Proactiveness:
- Empowering individuals to focus on what they can control reduces stress and creates a sense of accomplishment.
- Expanding the Circle of Influence:
- By focusing on actionable changes, individuals and teams build momentum, leading to broader, systemic improvements.
Examples in Mob Programming:
-
Therapeutic Impact: A developer overwhelmed by the volume of issues might focus on automating a single tedious task. This small win improves their morale and motivates further action.
-
Circle of Influence: A team automates repetitive deployment steps, freeing up time to tackle higher-level challenges.
Indicators of a Proactive Team
- Symptoms of a Reactive Team:
- Retrospectives focus on trivial issues (e.g., changing coffee brands in the break room).
- Problems persist because no one believes in their ability to effect change.
- Proactive Retrospectives:
- Address critical challenges, such as system reliability, team communication, or process inefficiencies.
Example of Proactive Symptom Identification:
- A team realizes their build pipeline is too slow.
- Instead of accepting it as “just the way it is,” they investigate bottlenecks and schedule work to optimize the pipeline.
Individual Proactiveness in Mobs
- Scaling Influence:
- Begin with small, actionable steps within your control.
- Handling Resistance:
- Proactive behavior includes resilience in the face of negative responses.
- Rather than getting discouraged by team rejection of ideas, focus on refining and reintroducing them later.
Examples in Mob Programming:
- A mob observes inefficiency in their manual database processes.
- Reactive: Continue using manual steps and complain about the time wasted.
- Proactive: One member introduces a learning session to teach automation techniques, gradually leading the team toward fully automated workflows.
Long-Term Impact
-
Virtuous Loops in Retrospectives:
- Continuous reflection and action amplify growth and innovation over time.
- Teams reach new levels of efficiency by breaking through previously perceived limits.
-
Butterfly Effect of Small Actions:
- Minor changes (e.g., introducing a single automation script) cascade into significant improvements.
Example:
- A team begins by automating a simple task like error reporting.
- This sparks interest in automating related processes, ultimately leading to a fully automated CI/CD pipeline.
Closing Thoughts
- Key Takeaways:
- Proactivity is foundational for teamwork, mob programming, and personal growth.
- Focusing on what you can influence fosters resilience, innovation, and a positive team culture.
- Practical Advice:
- Start small: Identify one area where you can make a difference today.
- Encourage a proactive mindset in your team by modeling the behavior and celebrating small wins.
Habit 2: Begin with the End in Mind
Introduction: Context and Framework
Key Premises:
- Habit Discussed:
- Begin with the End in Mind from Stephen Covey’s The 7 Habits of Highly Effective People.
- This habit emphasizes clarity of purpose and vision, both individually and collectively, before undertaking a task.
- Application to Mob Programming:
- Mob programming amplifies team dynamics and collaboration.
- Collective alignment on the “end” becomes crucial for sustainable, high-quality development.
Why This Matters in Software Development:
- Misaligned goals in software engineering lead to inefficiencies:
- Example: Teams refactoring without clear direction may create over-engineered or irrelevant solutions.
- Principles and vision serve as a compass:
- Avoids “activity traps” like working hard on irrelevant tasks.
- Encourages focus on long-term outcomes.
Definition:
- Covey’s focus is on intentionality: identifying clear goals and aligning efforts toward achieving them.
- Metaphor: A team hacking through a forest without a map may work efficiently but go nowhere.
Software Development Parallel:
- Without a clear “end”:
- Development effort can lead to technical debt, rework, or misaligned deliverables.
- Example: Implementing features based on unclear or shifting requirements may result in costly rewrites.
- With a clear “end”:
- Enables effective prioritization, better technical decisions, and alignment with customer needs.
Individual vs. Collective in Mob Programming
Individual Perspective:
-
Personal North Star:
- Developers often bring individual priorities, like learning new technologies, improving skills, or adhering to coding practices.
- Potential Conflict:
- Example: A developer focusing on experimenting with a new framework might divert the mob from delivering value.
- Solution:
- Align individual goals with mob objectives. For instance, experimental learning can be integrated if it aligns with team deliverables.
-
Avoiding Personal Biases:
- Individuals should avoid anchoring on personal opinions that detract from the team’s shared purpose.
- Example: A developer insisting on TDD in all situations may delay progress on exploratory prototypes.
Collective Perspective:
-
Shared Vision:
- Mob programming requires the collective to align on a unified vision of the “end.”
- Challenge:
- Diverse team values (e.g., prioritizing speed vs. maintainability) may cause tension.
- Solution:
- Collaborative discussions to establish common ground, using tools like a team charter.
-
Benefits of Alignment:
- Teams that agree on the “end in mind” work more cohesively, reduce friction, and deliver value faster.
- Example:
- A mob building a payment gateway agrees on key goals: scalability, security, and compliance. This alignment ensures decisions reflect these priorities, avoiding shortcuts that compromise quality.
Anti-Patterns in Mob Programming
1. Product Owner (PO)-Centered Mobs
Description:
- Mobs overly focused on satisfying the PO’s immediate needs often:
- Overprioritize short-term deliverables.
- Neglect technical practices like testing or documentation.
- Example:
- A PO requests a feature, and the mob rushes to deliver it without adding tests. A bug in production later doubles the effort required to fix it.
Consequences:
- Leads to unstable teams due to constant task-switching.
- Reduces psychological safety, as the mob fears questioning the PO.
Solution:
- Shift focus to principles like delivering long-term value.
- Example: Using cost of delay to prioritize tasks ensures the team balances urgent and strategic needs.
- Encourage open dialogue with the PO.
- Example: The mob presents trade-offs for rushing a feature (e.g., higher risk of defects).
2. Enemy-Centered Mobs
Description:
- Individuals who focus on the perceived flaws of teammates disrupt mob dynamics.
- Example:
- A developer criticizes another’s coding skills, creating tension and reducing productivity.
Consequences:
- Lowers team morale and psychological safety.
- Encourages mob members to disengage rather than collaborate.
Solution:
- Promote coaching over criticism.
- Example: Instead of highlighting flaws, a skilled developer mentors others during the mob session.
- Focus on collective improvement.
- Example: Use retrospectives to address skill gaps constructively.
3. Activity Without Purpose
Description:
- Mobs that focus on “doing” without clear outcomes fall into the “activity trap.”
- Example:
- A mob spends hours refining a small piece of code that doesn’t contribute to the sprint goal.
Consequences:
- Waste of resources and time.
- Frustration when progress doesn’t translate into meaningful results.
Solution:
- Establish a clear, shared purpose at the beginning of each session.
- Example: Use tools like “definition of done” to ensure tasks contribute to project goals.
Principle-Centered Mobs
Characteristics of Principle-Centered Teams:
-
Guided by Core Principles:
- Examples:
- TDD for quality assurance.
- Continuous refactoring for maintainability.
- Lean principles to avoid waste.
- Example: A mob agrees to follow the Scout Rule: “Leave the codebase cleaner than you found it.”
- Examples:
-
Consistent Framework for Decisions:
- Example: When faced with a trade-off (e.g., speed vs. quality), the mob defaults to principles like sustainable delivery.
How to Develop Principle-Centered Mobs:
- Create a Team Charter:
- Define shared principles and objectives.
- Example: “Our mob prioritizes TDD and CI/CD practices over quick fixes.”
- Embed Principles in Workflow:
- Example: Integrate retrospectives after each mob session to reflect on adherence to principles.
Practical Techniques to Align Mobs
Diagnostic Questions:
- Why Are We Doing This?
- Use the “5 Whys” to uncover root motivations.
- Example: A team fixing a bug asks, “Why did this bug occur?” and uncovers a deeper need for improved testing practices.
- What Principles Guide Us?
- Example: A mob might prioritize customer value over output by aligning with the lean principle of reducing waste.
Reframing with Storytelling:
-
Historical Lessons:
- Share past experiences to guide current decisions.
- Example: A senior developer shares how ignoring documentation created onboarding challenges, encouraging the mob to prioritize documentation.
-
Ship of Theseus Analogy:
- Helps teams see their codebase as an evolving entity.
- Example: A mob realizes that even small refactorings contribute to the product’s long-term health.
Amplification in Mob Programming
Visibility of Team Dynamics:
- Mobbing highlights team emotions and challenges in real-time.
- Example: A mob notices frustration over task-switching, prompting a discussion about better backlog management.
Key Takeaways for Software Engineering
- Principle-Centered Goals:
- Align mob programming efforts with principles like clean code, sustainability, and customer value.
- Avoid Anti-Patterns:
- Watch for traps like PO-centered mobs or personal conflicts.
- Enable Continuous Alignment:
- Use tools like charters, retrospectives, and storytelling to ensure the mob remains focused on its North Star.
Principles of Prioritization
Introduction
- Hosts and Topic Introduction:
- Hosts: Chris Lucian and Austin Chadwick.
- Focus: Third habit of the seven habits of highly effective mobbers - “Put First Things First.”
Context and Personal Insights
-
Personal Reflections:
- Importance of prioritization and principles.
- Introduction to foundational quotes, including “schedule your priorities.”
- Reflection on how prioritization aligns with principles.
-
Scheduling Priorities:
- Importance of scheduling based on principles, not just immediate tasks.
- Highlight: Eisenhower Matrix as a prioritization framework.
-
Eisenhower Matrix Overview:
- Quadrants Explained:
- Q1 (Urgent and Important): Crisis, emergency deadlines.
- Q2 (Not Urgent but Important): Proactive work, learning, relationship building.
- Q3 (Urgent but Not Important): Distractions.
- Q4 (Not Urgent, Not Important): Waste activities.
- Emphasis on Q2 as the “Effectiveness Quadrant.”
- Quadrants Explained:
Practical Application in Mob Programming
-
Connecting Eisenhower Matrix to Mob Programming:
- Learning and renewal (lightning talks).
- Relationship building within teams (e.g., hikes and lean coffees).
- Avoidance of Q3 and Q4 activities by aligning tasks with team goals.
-
Avoiding Burnout:
- Dangers of overemphasizing Q1.
- Strategies for balancing workloads and preventing crisis mode.
- Cultivating a healthy working environment.
Cultural and Strategic Adjustments
-
Cultural Challenges:
- Addressing organizational tendencies to overprioritize short-term gains.
- Encouraging long-term thinking aligned with principles.
-
Procrastination and Its Impact:
- How delays can lead to crisis (Q1).
- Preventive strategies for teams, including regular retrospectives and forward-planning.
Practical Examples
-
Exercise and Maintenance Analogy:
- Exercise prevents future health crises—similarly, proactive refactoring prevents debugging crises.
- Arlo Belshee’s “Bug Zero” approach to preventing a firefighting culture in software teams.
-
Firefighting in Software:
- Analogy of avoiding being addicted to the “fires” (bugs and urgent issues).
- Prioritizing sustainable practices over short-term fixes.
Team Dynamics
-
Role of Teams in Prioritization:
- Mob programming as a tool for reducing distractions (Q3) and increasing focus on Q2 activities.
- Facilitators’ roles in promoting efficiency and preventing unnecessary interruptions.
-
Delegation and Automation:
- Delegating Q3 tasks to reduce workload.
- Automating repetitive tasks for increased efficiency.
Leadership and Decision-Making
-
Leadership Strategies:
- Teaching teams to focus on the most important tasks, even under urgency.
- Balancing kindness with directness in setting priorities.
-
Mob Programming as Real-Time Alignment:
- Collaborative prioritization during mob sessions.
- Addressing distractions in real-time and maintaining team alignment.
Conclusion and Reflection
-
Strategies for Implementation:
- Using Kanban boards to visualize priorities within Eisenhower quadrants.
- Regularly reviewing team workflows to ensure alignment with Q2 goals.
-
Closing Thoughts:
- Encouragement for individuals and teams to adopt these prioritization habits.
- Invitation for viewers to share and reflect on the discussed principles.