0/100 Rule: Ending Ambiguous Progress

"How many percent is this task complete?"

"Um... about 70%?"

Let's stop these ambiguous answers.

0% or 100%. No middle ground.

What is the 0/100 Rule?

A rule that expresses task status in only two ways.

def get_task_progress(task):
    # Traditional way
    # return "Roughly 60~70%?"  # Ambiguous

    # 0/100 Rule
    if task.is_complete():
        return 100
    else:
        return 0
    # Done. Simple and clear!

Why 0/100 Rule?

Eliminates Subjectivity

Developer A says "70% complete", Developer B sees the same task and says "40% complete".
PM thinks "about 50%?"

Why do they see the same task differently?
Because each has different criteria.

0/100 Rule completely eliminates this subjectivity.
Done or not done. Simple and clear.

Faces Truth

# Illusion
illusion = {
    "UI 90% complete": True,
    "Logic 80% complete": True,
    "Overall progress": "85%"  # Almost done!
}

# Reality (0/100 Rule)
reality = {
    "UI complete": False,  # 0%
    "Logic complete": False,  # 0%
    "Overall progress": "0%"  # Nothing finished yet...
}

Cruel but honest.

Applying 0/100 Rule

Step 1: Break Tasks Small

# ❌ Bad example: Large chunk
big_task = {
    "name": "User Management System",
    "estimate": "2 weeks",
    "status": 0  # 0% for 2 weeks...
}

# ✅ Good example: Small pieces
small_tasks = [
    {"name": "Signup API", "hours": 4, "done": True},   # 100%
    {"name": "Signup UI", "hours": 3, "done": True},    # 100%
    {"name": "Login API", "hours": 4, "done": True},     # 100%
    {"name": "Login UI", "hours": 3, "done": False},     # 0%
    {"name": "Profile API", "hours": 3, "done": False},    # 0%
    {"name": "Profile UI", "hours": 3, "done": False}      # 0%
]

# Progress = 3/6 = 50% (Clear!)

Step 2: Define Completion Criteria

Task: Login API
Completion Checklist: □ Feature Implementation
  □ Input Validation
  □ Error Handling
  □ Unit Tests
  □ Code Review
  □ Documentation

Rule: All items checked = 100% / Any unchecked = 0%

Step 3: Daily Tracking

In daily standup:

const dailyUpdate = () => {
  console.log('=== Today's Status ===');

  tasks.forEach((task) => {
    console.log(`${task.name}: ${task.done ? '✅ 100%' : '⭕ 0%'}`);
  });

  const completed = tasks.filter((t) => t.done).length;
  const total = tasks.length;

  console.log(`Overall: ${completed}/${total} complete`);
};

Numbers are clear, so no dispute.

Real Project Application Case

E-commerce Payment System

## Project: Payment System (Total 32 hours)

### Card Payment (12 hours)

- [x] PG Integration (4h) ✅ 100%
- [x] Payment Validation (3h) ✅ 100%
- [ ] Error Handling (3h) ⭕ 0%
- [ ] Testing (2h) ⭕ 0%
      Progress: 2/4 = 50%

### Easy Payment (8 hours)

- [ ] KakaoPay (4h) ⭕ 0%
- [ ] NaverPay (4h) ⭕ 0%
      Progress: 0/2 = 0%

Overall Progress: 2/10 = 20% (Accurate!)

The whole team sees the same number. No room for interpretation.

Variations of 0/100 Rule

0/50/100 Rule

When intermediate milestones are needed:

def fifty_percent_rule(task):
    """Acknowledge 50% when code review passes"""

    if task.is_complete():
        return 100
    elif task.code_review_passed():
        return 50  # Intermediate acknowledgment
    else:
        return 0

20/80 Rule

A way to acknowledge start:

function twentyEightyRule(task) {
  if (task.isComplete) return 100;
  if (task.isStarted) return 20; // Start bonus
  return 0;
}

But be careful. All tasks might stop at 20%.

Advantages of 0/100 Rule

Predictability

Instead of ambiguous "almost done", "little left",
You can say "3 of 5 complete, 2 remaining."

Remaining work is clear, so completion time is predictable.

Transparency

const teamDashboard = {
  DevKim: {
    assigned: 5,
    completed: 3,
    progress: '3/5 (60%)',
  },
  DesignerLee: {
    assigned: 4,
    completed: 4,
    progress: '4/4 (100%) 🎉',
  },
  QAPark: {
    assigned: 6,
    completed: 1,
    progress: '1/6 (17%)',
  },
};

Who's in what state is visible at a glance.

Motivation

You see completed tasks daily.
Just seeing checkboxes get ✅ one by one gives a sense of achievement.

Much more satisfying than ambiguous percentages slowly rising.

Introducing to Team

Week 1: Pilot

Monday: Select 1 project, break into 10 tasks
Wednesday: Apply 0/100 rule, compare with existing method
Friday: Team feedback, discuss improvements

Week 2-3: Expansion

Apply to entire team, introduce tools, improve process

Precautions

Tasks Too Large

0% for 2 weeks lowers team morale.
Break tasks smaller.

Formal Checklists

# ❌ Bad checklist
- [ ] Coding complete  # Too ambiguous

# ✅ Good checklist
- [ ] POST /api/login endpoint implementation
- [ ] Email format validation (regex)
- [ ] Password bcrypt hashing
- [ ] JWT token generation and return
- [ ] 401/403 error handling

More specific is better.

Tools and Automation

Git Commit Integration

#!/bin/bash
# Auto-check based on commit message

if [[ $1 == *"[done]"* ]]; then
  echo "✅ Task marked as 100% complete"
elif [[ $1 == *"[wip]"* ]]; then
  echo "⭕ Task still at 0%"
fi

Simple Tracker

class SimpleTracker {
  getProgress() {
    const total = this.tasks.size;
    const done = [...this.tasks.values()].filter((v) => v).length;

    return {
      tasks: `${done}/${total}`,
      percentage: Math.round((done / total) * 100),
      remaining: [...this.tasks.entries()].filter(([_, done]) => !done).map(([name, _]) => name),
    };
  }
}

Performance Measurement

Before vs After

Actual results from a startup:

metrics_before = {
    "project_delay_rate": 65,
    "prediction_accuracy": 45,
    "team_trust": 6.2
}

metrics_after_3months = {
    "project_delay_rate": 25,  # 62% improvement
    "prediction_accuracy": 82,      # 82% improvement
    "team_trust": 8.5        # 37% improvement
}

Conclusion

0/100 Rule is simple but powerful.

Core Principles:

• Tasks are either complete or incomplete
• No ambiguous percentages
• Break tasks small
• Clear completion criteria

It may feel extreme at first,
But you'll soon realize how comfortable this clarity is.

Instead of ambiguous words like "70% complete",
Say "7 of 10 complete."

Much more accurate and trustworthy.

---

Need clear project tracking? Check out Plexo.