전규현 (Jeon gyuhyeon)

Posted on Jan 20

WIP Limits: To Finish Faster, Start Less

#agile #management #productivity #softwaredevelopment

"5 developers, so 5 tasks simultaneously, right?"

No.

Actually, doing only 2 will finish faster.

This is the magic of WIP (Work In Progress) limits.

The Illusion of Multitasking

Monday morning, what does your task list look like?

Bug fix 30%, new feature development 20%, code review pending, documentation 10%, meeting prep...

Friday evening?

Bug fix 70%, new feature development 40%, code review rushed, documentation 15%, meeting prep hurried...

Completed tasks: 0

The Cost of Context Switching

Every time we switch tasks, our brain pays a cost.

function calculateSwitchingCost(numberOfTasks) {
  const baseProductivity = 100;
  const switchingPenalty = 20; // 20% loss per task

  if (numberOfTasks === 1) {
    return baseProductivity;
  }

  const productivity = baseProductivity - (numberOfTasks - 1) * switchingPenalty;
  return Math.max(productivity, 20);
}

console.log('1 task:', calculateSwitchingCost(1), '%'); // 100%
console.log('3 tasks:', calculateSwitchingCost(3), '%'); // 60%
console.log('5 tasks:', calculateSwitchingCost(5), '%'); // 20%

Doing 5 tasks simultaneously drops productivity to 20%.

Every task switch: save current state, recall next task, open files, recover focus...
One switch wastes 43 minutes. 5 switches per day? 3.5 hours disappear.

The Principle of WIP Limits

Little's Law

Average wait time = WIP / Throughput

Without WIP limits, doing 10 tasks simultaneously takes 5 days each.
Limit WIP to 3? Done in 1.5 days.

Start less to finish faster.

Managing WIP with Kanban Board

class KanbanBoard {
  constructor() {
    this.columns = {
      backlog: { limit: null, tasks: [] },
      todo: { limit: 5, tasks: [] },
      doing: { limit: 2, tasks: [] }, // Key: WIP limit!
      review: { limit: 3, tasks: [] },
      done: { limit: null, tasks: [] },
    };
  }

  canAddToColumn(columnName) {
    const column = this.columns[columnName];
    if (!column.limit) return true;
    return column.tasks.length < column.limit;
  }
}

Setting 2-task limit on Doing column means you must finish existing work to start new.
This is the Pull system.

Real Application Case

Results from a 5-person team introducing WIP limits.

Before: Unlimited WIP

In-progress tasks: 15
Average completion time: 2 weeks
Monthly completion: 8
Team stress: High

After: WIP Limit Introduced (3)

In-progress tasks: 3
Average completion time: 3 days
Monthly completion: 20 (2.5x increase!)
Team stress: Low

How to Set WIP Limits

Finding Appropriate WIP

function findOptimalWIP(teamSize, taskComplexity) {
  // Basic formula: 50-70% of team size
  let baseWIP = Math.floor(teamSize * 0.6);

  const adjustments = {
    simple: 1.2, // Simple tasks: OK to increase WIP
    medium: 1.0, // Medium: default
    complex: 0.7, // Complex tasks: reduce WIP
    research: 0.5, // Research/exploration: reduce more
  };

  return Math.max(1, Math.floor(baseWIP * adjustments[taskComplexity]));
}

// 5-person team, complex tasks
console.log(findOptimalWIP(5, 'complex')); // 2 recommended

Phased Introduction

Week 1: Measure Current State

Record in-progress task count
Measure completion time
Identify bottleneck points

Week 2: Loose Limit

Limit to 70% of current WIP
Allow exceptions
Collect team feedback

Week 3-4: Optimization

Gradually reduce WIP
Resolve bottlenecks
Improve process

Finding Bottlenecks

Another advantage of WIP limits is immediately discovering bottlenecks.

If current column is full and next column is empty? Next column is the bottleneck.
If code review is bottleneck, must improve review process.

Additional Effects of WIP Limits

Quality Improvement

Before WIP limits: Bug rate 15%, test coverage 45%
After WIP limits: Bug rate 5%, test coverage 75%

Focus increases, mistakes decrease.

Predictability

Before WIP limits: "About 2 weeks?" → Actually 1-6 weeks
After WIP limits: "3 days (±1 day)" → Actually 2-4 days

Prediction accuracy rises from 30% to 85%.

Common Mistakes and Solutions

Mistake 1: Too Strict Start

Reducing current WIP 20 to 3 from day one causes team backlash.
Reduce gradually: 20 → 15 → 10 → 7 → 5.

Mistake 2: No-Exception Rules

class FlexibleWIP {
  handleEmergency(task) {
    if (task.priority === 'CRITICAL') {
      // Allow temporary +1 for emergencies
      this.currentLimit = this.baseLimit + 1;
      console.log('WIP temporarily increased for emergency task');

      // But, defer one other task
      return 'Move one other task to backlog';
    }
  }
}

Conclusion

WIP limits are counterintuitive.

Must escape the illusion that "starting more finishes more."

Truth: Start less to finish more.

Core principles:

Limit simultaneous work
Focus on completion
Use Pull system
Find and resolve bottlenecks

Try WIP limits in your next sprint.
First week will be awkward, but you'll soon be amazed by the effect.

"Stop starting, start finishing."

Need effective project management? Check out Plexo.

DEV Community