Categoria: management

Playing the Infinite Game

Ever wondered why some engineering teams consistently deliver amazing results while others struggle with endless firefighting?
I think the secret often lies not in individual brilliance, but in understanding the games we’re playing. Let’s see if it could make sense trying to apply game theory in engineering management.

The Management Puzzle: What Are they Really Trying to Solve?

Let’s be honest – managing engineers sometimes feels like herding very intelligent cats who speak in algorithms. The core challenges typically boil down to:

1. How do we align individual incentives with team goals?
2. How do we optimize for long-term success rather than short-term wins?
3. How do we create systems that naturally promote collaboration?

If you’re nodding along, congratulations – you’ve just identified the classic elements of what game theorists call a “multiplayer dynamic game with incomplete information.”
Sounds fancy, right? Don’t worry, we’ll break it down with some real-world examples.

Dynamic, Simultaneous, Multiplayer Games with Limited Information

Let’s break this mouthful down:

• Dynamic: The game changes as you play it (like your codebase)
• Simultaneous: Players make moves without knowing others’ choices (like parallel development)
• Multiplayer: Multiple stakeholders involved (developers, users, business)
• Limited Information: Nobody has the full picture (just like real software projects!)

This is why simplistic “if-then” management strategies often fail. We’re not playing chess (perfect information) or poker (zero-sum); we’re playing something more like a massive multiplayer online game where the rules themselves evolve.

The Zero-Sum Trap

Here’s a common scenario: Your team needs to ship a critical feature. Alice is brilliant at backend work, while Bob excels at frontend. Traditional management might focus on individual metrics – lines of code, tickets closed, etc. But that’s playing a zero-sum game where Alice and Bob compete for recognition rather than collaborate for success.

Instead, let’s apply game theory principles to create a positive-sum game:

Practical Applications

1. Design Better Incentive Systems

Let’s explore some concrete system-level incentives that create positive-sum games:

The Documentation Multiplier

# Components:
# story_points_completed: Number of story points delivered in sprint (0-100)
# documentation_coverage: % of code with clear documentation (0.0-1.0)
# knowledge_sharing_index: Number of knowledge sharing activities / team size
# individual_output: Tasks completed per sprint normalized to 1.0

sprint_success = story_points_completed * documentation_coverage
team_performance = individual_output * (1 + knowledge_sharing_index)

# Example:
# A team completing 40 points with 80% documentation: 40 * 0.8 = 32
# An individual completing 10 tasks with 3 knowledge shares in a team of 5:
# 10 * (1 + 3/5) = 16

The Quality-Speed Balance

# Components:
# speed: Tasks completed per week / team capacity (0.0-1.0)
# quality: (100 - bugs_found) / 100 (0.0-1.0)
# Both metrics normalized to 1.0 for fair comparison

# Traditional approach measures them separately
performance = (speed + quality) / 2

# System thinking combines them multiplicatively
performance = speed * quality

# Example:
# Traditional: (0.9 speed + 0.5 quality) / 2 = 0.7
# System thinking: 0.9 * 0.5 = 0.45 (penalizes quality issues more)

The Learning Network Effect

# Components:
# base_productivity: Standard team velocity (story points/sprint)
# cross_trained_pairs: Number of engineer pairs who can cover each other's work
# total_possible_pairs: n*(n-1)/2 where n is team size
# technical_output: Completed features per sprint
# unique_viewpoints_contributed: Number of team members actively contributing to technical discussions

team_capability = base_productivity * (1 + cross_trained_pairs/total_possible_pairs)
innovation_score = technical_output * unique_viewpoints_contributed

# Example for a team of 5:
# Base productivity: 30 points
# Cross-trained pairs: 6 out of 10 possible pairs
# team_capability = 30 * (1 + 6/10) = 48 points
# 
# If they complete 5 features with all 5 members contributing:
# innovation_score = 5 * 5 = 25

This multiplicative approach to metrics creates several beneficial effects:

1. Zero in any component drastically reduces overall performance
2. Improvements in any area benefit the entire system
3. Maximum performance requires balanced optimization across all factors

These formulas can be adjusted based on team size and organizational priorities, but the key is maintaining the multiplicative relationship between components. This ensures that no single metric can be optimized at the expense of others without harming overall performance.

2. Understanding Reputation Formation

In game theory, reputation isn’t just about being “good” or “bad” – it’s a complex dynamic system that evolves through repeated interactions. Think of it as your team’s internal cryptocurrency: every interaction either mines or burns tokens of trust.

Consider how senior engineers build reputation: they don’t just write good code; they create environments where others can write good code. This is what game theorists call “reputation externalities” – your actions don’t just affect your reputation, but influence how others build theirs.

The Trust Equation

Research in game theory suggests that trust can be modeled as:

# Components:
# credibility: Track record of making good on promises (0-1)
# reliability: Consistency of behavior over time (0-1)
# intimacy: Psychological safety created in team (0-1)
# self_orientation: Focus on self vs team (-1 to 1)

Trust = (credibility + reliability + intimacy) / (1 + self_orientation)

# Example:
# High performing manager: (0.9 + 0.8 + 0.7) / (1 + 0.2) = 2.0
# Self-centered manager: (0.9 + 0.8 + 0.7) / (1 + 0.8) = 1.33

Good managers understand that reputation isn’t built through grand gestures but through consistent behavior in small interactions. Here’s how to play this game effectively:

1. Information Symmetry

• Share context behind decisions
• Admit when you don’t know something
• Be transparent about constraints and trade-offs

2. Repeated Games

• Regular 1:1s become trust-building opportunities
  -> tuxerrante.github.io/the-managers-path
  -> small-improvements.com/1-on-1-meetings
• Consistent feedback loops create predictability
• Follow-through on commitments builds credibility

3. Signal Amplification

• Public recognition of team contributions
• Taking responsibility for failures
• Defending team interests in organizational politics

Remember: in game theory, the most successful strategies in repeated games tend to be “nice, forgiving, and non-envious.” This translates to management as:

• Nice: Start with trust and support
• Forgiving: Allow for mistakes and learning
• Non-envious: Celebrate team success over personal recognition

3. The Game Within The Game

Here’s a secret about game theory: there’s always a bigger game. That bug fix you’re working on? It’s part of a feature. That feature? Part of a product. That product? Part of a company’s vision to change the world.

Understanding this “nested games” concept is crucial for motivation. When engineers see how their daily work connects to larger outcomes, they’re more likely to make decisions that optimize for the bigger game. It’s the difference between laying bricks and building a cathedral.

But Wait… What About Reality?

Now, I hear you thinking: “This all sounds great in theory, but what about…”

The Counter-Arguments

1. “Individual brilliance matters!” Yes, but brilliant individuals in toxic systems produce suboptimal results. Think of it like a Formula 1 car with square wheels.
2. “We need to move fast!” Short-term thinking is exactly what game theory helps us avoid. Remember, every game theorist’s favorite game is the infinite game.
3. “Our industry is naturally competitive!” Perfect! That means understanding game theory gives you a competitive advantage.

Bringing It All Together

The key to successful engineering management isn’t just understanding technology or people – it’s understanding the games we create and play every day. By applying game theory principles, we can build systems that:

• Naturally align individual and team incentives
• Promote long-term thinking
• Turn potential competitors into collaborators

Want to Dive Deeper?

1. “The Evolution of Trust” – Nicky Case’s interactive guide (2020)
2. Trust beyond reason – drmaciver.com
3. MIT OpenCourseWare: Game Theory
4. “Winning at Game Theory with The Price is Right” – John Farrier (2023)
5. Strategy and Game Theory for Management by IIMA