Как ты расставляешь приоритеты в задачах, если все они имеют одинаковую важность?

Как расставлять приоритеты в задачах при одинаковой важности

Это частая ситуация в реальной разработке. За 10+ лет практики я выработал систематический подход к приоритизации, когда формальная важность одинакова.

1. Анализ Влияния и Зависимостей

Первое, что я делаю — анализирую, какие задачи блокируют других:

tasks = [
    {'id': 1, 'name': 'Setup CI/CD pipeline', 'blocked_by': 0, 'blocks': ['auth', 'deploy']},
    {'id': 2, 'name': 'User authentication', 'blocked_by': 1, 'blocks': ['api', 'dashboard']},
    {'id': 3, 'name': 'Fix button styling', 'blocked_by': 0, 'blocks': []},
    {'id': 4, 'name': 'API endpoints', 'blocked_by': 1, 'blocks': ['frontend']},
]

def calculate_impact_score(task):
    # Задача более ценна, если она блокирует другие
    blocking_count = len(task['blocks'])
    return blocking_count

# Сортируем по влиянию
sorted_tasks = sorted(tasks, key=calculate_impact_score, reverse=True)
# Результат: CI/CD (блокирует 2), затем auth, API, затем styling

Задачи, которые блокируют других, получают более высокий приоритет.

2. Принцип Минимальных Усилий с Максимальным Результатом

from dataclasses import dataclass
from enum import Enum

@dataclass
class Task:
    name: str
    estimated_hours: int
    expected_value: int  # 1-10 scale
    
class PriorityStrategy:
    @staticmethod
    def effort_ratio(task: Task) -> float:
        """Value per hour of work"""
        if task.estimated_hours == 0:
            return 0
        return task.expected_value / task.estimated_hours

tasks = [
    Task('Fix critical bug', 2, 8),      # Ratio: 4.0
    Task('Add feature X', 8, 7),         # Ratio: 0.875
    Task('Refactor module', 10, 5),      # Ratio: 0.5
    Task('Update docs', 1, 3),           # Ratio: 3.0
]

strategy = PriorityStrategy()
for task in sorted(tasks, key=strategy.effort_ratio, reverse=True):
    print(f'{task.name}: {strategy.effort_ratio(task):.2f}')

# Результат:
# Fix critical bug: 4.0
# Update docs: 3.0
# Add feature X: 0.88
# Refactor module: 0.5

Зачастую маленькие быстрые задачи дают огромное значение (документация, исправления багов).

3. Принцип RICE — Reach, Impact, Confidence, Effort

Этот фреймворк используют в Stripe и других крупных компаниях:

from enum import IntEnum

class RiceScore:
    """RICE scoring framework"""
    
    @staticmethod
    def calculate_score(
        reach: int,           # Сколько пользователей затронуто (1-10)
        impact: int,          # Масштаб влияния (1-10)
        confidence: int,      # Уверенность в оценке (0-100%)
        effort_weeks: float   # Сколько недель потребуется
    ) -> float:
        return (reach * impact * (confidence / 100)) / effort_weeks

scores = {
    'Add dark mode': RiceScore.calculate_score(reach=8, impact=5, confidence=80, effort_weeks=4),
    'Fix login bug': RiceScore.calculate_score(reach=10, impact=9, confidence=100, effort_weeks=0.5),
    'Refactor tests': RiceScore.calculate_score(reach=1, impact=3, confidence=100, effort_weeks=2),
    'Add analytics': RiceScore.calculate_score(reach=7, impact=6, confidence=60, effort_weeks=3),
}

for task, score in sorted(scores.items(), key=lambda x: x[1], reverse=True):
    print(f'{task}: {score:.1f}')

# Результат:
# Fix login bug: 180.0
# Add dark mode: 8.0
# Add analytics: 8.4
# Refactor tests: 1.5

4. Срочность vs Важность (Eisenhower Matrix)

От Дэвида Аллена и Стивена Кови:

from enum import Enum

class Urgency(Enum):
    LOW = 1
    HIGH = 2

class Importance(Enum):
    LOW = 1
    HIGH = 2

@dataclass
class TaskWithContext:
    name: str
    urgency: Urgency
    importance: Importance

quadrants = {
    (Importance.HIGH, Urgency.HIGH): 'DO FIRST - Critical & Urgent',
    (Importance.HIGH, Urgency.LOW): 'SCHEDULE - Important but not urgent',
    (Importance.LOW, Urgency.HIGH): 'DELEGATE - Urgent but not important',
    (Importance.LOW, Urgency.LOW): 'ELIMINATE - Neither urgent nor important',
}

tasks = [
    TaskWithContext('Production bug fix', Urgency.HIGH, Importance.HIGH),
    TaskWithContext('Code refactoring', Urgency.LOW, Importance.HIGH),
    TaskWithContext('Meeting request', Urgency.HIGH, Importance.LOW),
    TaskWithContext('Reorganize files', Urgency.LOW, Importance.LOW),
]

for task in tasks:
    key = (task.importance, task.urgency)
    quadrant = quadrants[key]
    print(f'{task.name}: {quadrant}')

5. Блокирующие Факторы и Context Switching

class ContextSwitchCost:
    """Стоимость переключения контекста"""
    
    @staticmethod
    def prioritize_by_context(tasks, current_context):
        """
        Задачи в одном контексте дешевле в выполнении
        """
        # Если работаю с backend — пусть backend задачи будут выше
        same_context_bonus = 100  # произвольное число
        
        scored = []
        for task in tasks:
            score = task['base_score']
            if task['context'] == current_context:
                score += same_context_bonus
            scored.append((task['name'], score))
        
        return sorted(scored, key=lambda x: x[1], reverse=True)

current_context = 'backend'
tasks = [
    {'name': 'Add API endpoint', 'context': 'backend', 'base_score': 5},
    {'name': 'Add tests', 'context': 'backend', 'base_score': 4},
    {'name': 'Fix CSS', 'context': 'frontend', 'base_score': 6},
]

print(prioritize_by_context(tasks, current_context))
# API endpoint и тесты выше, чем CSS (избегаем context switch)

Переключение контекста очень дорого — лучше сделать несколько backend задач подряд.

6. Моментум и Мотивация

class MomentumFactor:
    """
    Иногда нужно учитывать мотивацию и momentum
    """
    
    @staticmethod
    def should_continue_with_current(current_task, next_tasks):
        # Если я в потоке (flow state) — доделаю текущее
        # Даже если есть более приоритетные (но не критичные) задачи
        
        # Прерывание из потока стоит дороже, чем завершение текущего
        if current_task['is_blocking'] or current_task['is_critical']:
            return False  # Прерывать надо
        
        # Если текущее — 15 минут, заканчиваю
        if current_task['remaining_minutes'] < 15:
            return True
        
        # Если есть критическое — переключаюсь
        if any(t['is_critical'] for t in next_tasks):
            return False
        
        return True

7. Мой Практический Процесс

class PriorityFramework:
    def rank_tasks(self, tasks):
        """
        Мой реальный процесс в компании
        """
        scores = []
        
        for task in tasks:
            score = 0
            
            # 1. Критичность (блокирует развитие)
            if task['blocks_other_tasks']:
                score += 50
            
            # 2. RICE scoring
            rice = self._calculate_rice(task)
            score += rice
            
            # 3. Технический долг (может вырасти)
            if task['is_technical_debt']:
                score -= 10  # Снижаю приоритет, но не игнорирую
            
            # 4. Быстрые выигрыши (вдохновляет команду)
            if task['estimated_days'] <= 1 and task['value'] >= 5:
                score += 15
            
            # 5. Зависимости от других
            if task['depends_on_nothing']:
                score += 5
            
            scores.append((task['name'], score))
        
        return sorted(scores, key=lambda x: x[1], reverse=True)
    
    def _calculate_rice(self, task):
        reach = task.get('reach', 5)
        impact = task.get('impact', 5)
        confidence = task.get('confidence', 80)
        effort = task.get('effort_weeks', 2)
        
        return (reach * impact * confidence) // (effort * 100)

framework = PriorityFramework()
tasks = [
    {
        'name': 'Production bug in payment',
        'blocks_other_tasks': True,
        'reach': 10, 'impact': 10, 'confidence': 100,
        'effort_weeks': 1,
        'estimated_days': 0.5,
        'is_technical_debt': False,
        'depends_on_nothing': True,
        'value': 10
    },
    {
        'name': 'Add new feature',
        'blocks_other_tasks': False,
        'reach': 6, 'impact': 5, 'confidence': 70,
        'effort_weeks': 2,
        'estimated_days': 10,
        'is_technical_debt': False,
        'depends_on_nothing': True,
        'value': 7
    },
]

print(framework.rank_tasks(tasks))

Мой Чеклист при Одинаковой Важности:

1. Зависимости — что блокирует другое?
2. RICE Score — reach × impact × confidence / effort
3. Effort Ratio — value / hours
4. Context Switch — можно ли делать подряд похожие задачи?
5. Critical Path — нужно ли для deadline?
6. Quick Wins — есть ли легкие задачи с высокой ценностью?
7. Momentum — в каком контексте работаю сейчас?
8. Team Impact — какая задача больше вдохновит команду?

Заключение

Когда задачи имеют одинаковую важность, я использую RICE, effort ratio, и анализ зависимостей. Ключ — балансировать между длинными стратегическими проектами и быстрыми победами, которые поддерживают мотивацию.