Как происходит оценка трудности задач на нынешней работе?

Оценка трудности задач: методология и практика

Оценка трудности (effort estimation) — критическое умение в разработке. От неё зависит планирование, сроки, и самооценка собственных возможностей. Разбираю, как я это делаю за 10+ лет опыта.

1. Система Story Points (Agile методология)

Большинство команд используют относительную оценку через story points вместо часов:

// Fibonacci шкала (стандарт в Agile)
const storyPointScale = {
  1: 'Тривиально - 30 мин работы',
  2: 'Очень простая - 2-4 часа',
  3: 'Простая - половина дня',
  5: 'Средняя - 1-2 дня',
  8: 'Сложная - 2-4 дня',
  13: 'Очень сложная - неделя',
  21: 'Проект в себе - требует декомпозиции'
};

// Пример оценок фич на фронтенде
const tasks = {
  'Поправить отступ в кнопке': 1,
  'Добавить новое поле в форму': 2,
  'Создать новый компонент': 3,
  'Интегрировать новый API': 5,
  'Оптимизировать производительность': 8,
  'Переписать архитектуру state management': 13,
  'Мигрировать на новую версию React': 21 // нужно разбить
};

2. Факторы, влияющие на трудность

Это основные критерии, по которым я оцениваю задачу:

const estimationFactors = {
  // 1. Сложность логики
  complexity: {
    'Простая CRUD операция': 1,
    'Условная логика (if/else)': 3,
    'Сложная бизнес-логика': 5,
    'Математические алгоритмы': 8,
    'Machine Learning интеграция': 21
  },
  
  // 2. Количество затронутых компонентов
  scope: {
    'Один компонент': 1,
    'Один модуль (2-3 компонента)': 3,
    'Несколько модулей': 5,
    'Кросс-модульные изменения': 8,
    'Архитектурная переработка': 13
  },
  
  // 3. Тестирование
  testing: {
    'Только unit тесты': 1,
    'Unit + интеграционные': 2,
    'Нужно E2E тестирование': 3,
    'Ручное тестирование разных браузеров': 2,
    'Нужна поддержка старых браузеров': 3
  },
  
  // 4. Неизвестность (самый большой риск)
  uncertainty: {
    'Знаю точно как делать': '+0 points',
    'Есть сомнения по реализации': '+2 points',
    'Нужно разобраться в новой технологии': '+3 points',
    'Полная неизвестность': 'СТОП - нужна spike!'
  },
  
  // 5. Зависимости
  dependencies: {
    'Нет зависимостей': 0,
    'Ждём ответа от другого разработчика': '+2 points',
    'Ждём бэкенда с API': '+3 points',
    'Ждём дизайнера с макетом': '+2 points'
  }
};

3. Процесс оценки на планировании

Так выглядит реальный процесс на sprint planning:

const sprintPlanningProcess = {
  // Шаг 1: Получаем задачу
  step1_getTask: {
    what: 'Product Owner читает требования',
    example: 'Добавить поиск по вопросам с фильтрацией'
  },
  
  // Шаг 2: Уточняем требования
  step2_clarify: {
    questions: [
      'Что ровно нужно сделать?',
      'Какие граничные случаи?',
      'Есть ли дизайн-макет?',
      'Что считается "готово" (DoD)?'
    ]
  },
  
  // Шаг 3: Быстро думаю про реализацию
  step3_mentalDesign: {
    checklist: [
      'Какие компоненты затронешь?',
      'Нужны ли API изменения?',
      'Как будешь тестировать?',
      'Есть ли подводные камни?'
    ]
  },
  
  // Шаг 4: Считаю points
  step4_estimate: {
    formula: 'base (1-5) + complexity (+0-3) + testing (+0-3) + uncertainty (+0-3)',
    example: '3 + 2 + 1 + 0 = 6 points (округляю до 5 или 8)'
  },
  
  // Шаг 5: Обсуждаю с командой
  step5_discussion: {
    что_может_быть: [
      'Все согласны? Готово.',
      'Кто-то думает иначе? Обсуждаем.',
      'Большой разброс мнений? Делим задачу.'
    ]
  }
};

4. Реальные примеры оценок

const realExamples = {
  // Пример 1: Простой компонент
  example1: {
    task: 'Создать компонент Badge (цветной ярлык)',
    analysis: {
      complexity: 'Просто, только стили',
      components: 'Один новый компонент',
      testing: 'Простой снап-тест',
      dependencies: 'Нет'
    },
    estimate: 1
  },
  
  // Пример 2: Форма с валидацией
  example2: {
    task: 'Создать форму регистрации с валидацией',
    analysis: {
      complexity: 'Средняя - валидация + обработка ошибок',
      components: 'Form, Input, Button, ErrorMessage',
      testing: 'Unit тесты для валидации, E2E для потока',
      dependencies: 'Ждём API endpoint от бэка'
    },
    estimate: 5,
    breakdown: '2 дня разработка + 1 день тестирование'
  },
  
  // Пример 3: Интеграция нового API
  example3: {
    task: 'Интегрировать платёж через Stripe',
    analysis: {
      complexity: 'Высокая - новая библиотека, сложная логика',
      components: 'Несколько компонентов (форма, статус, ошибки)',
      testing: 'Нужны тесты с mocking Stripe',
      dependencies: 'Бэк реализует webhook'
    },
    estimate: 8,
    breakdown: '3 дня разработка + 1 день тестирование + 1 день дебаг'
  },
  
  // Пример 4: Оптимизация
  example4: {
    task: 'Оптимизировать производительность списка (10000 элементов)',
    analysis: {
      complexity: 'Высокая - требует новой архитектуры (virtualization)',
      components: 'VirtualList компонент, много изменений',
      testing: 'Бенчмарки performance, E2E на больших данных',
      uncertainty: 'Высокая - нужно разобраться в react-window'
    },
    estimate: 8,
    breakdown: 'День обучение + день разработка + день тестирование'
  }
};

5. Расчёт реального времени (когда нужно часы)

Иногда нужно перевести points в часы:

// Velocity команды (обычно рассчитывается за несколько спринтов)
const teamVelocity = {
  pointsPerDay: 5, // В среднем разработчик делает 5 points в день
  // или рассчитываем сами
  calculation: '40 часов в неделю / 8 часов на день = 5 часов в день'
};

function estimateHours(storyPoints) {
  const hoursPerPoint = 1; // обычно 1-2 часа на point
  return storyPoints * hoursPerPoint;
}

const examples = {
  '1 point': estimateHours(1) + ' = 1 час (макс 2 часа)',
  '3 points': estimateHours(3) + ' = 3 часа (обычно половина дня)',
  '5 points': estimateHours(5) + ' = 5 часов (день работы)',
  '8 points': estimateHours(8) + ' = 8 часов (2 дня)',
  '13 points': estimateHours(13) + ' = 13 часов (3+ дня)'
};

// Но это очень приблизительно!
// На практике добавляем буферы на неожиданное
const bufferFactor = 1.2; // +20% на неожиданное

6. Ошибки в оценке и как их избежать

const commonMistakes = {
  // Ошибка 1: Оцениваешь оптимистично (лучшего случая)
  optimismBias: {
    wrong: 'Если всё пойдёт идеально = 2 часа',
    right: 'Обычно получается = 4 часа (со всеми задержками)',
    fix: 'Оцениваешь реалистичный сценарий'
  },
  
  // Ошибка 2: Забываешь про тестирование
  forgotTesting: {
    wrong: 'Код = 4 часа, задача готова',
    right: 'Код = 4 часа + тесты = 2 часа + дебаг = 1 час = 7 часов',
    fix: 'Всегда считаешь testing и debugging'
  },
  
  // Ошибка 3: Давишь на себя, обещаешь невозможное
  promiseTooMuch: {
    wrong: 'Звучит срочно, обещу за 1 day (на самом деле 3)',
    right: 'Честно говоришь = 3 days, и даёшь +20% буфер',
    fix: 'Лучше выглядишь если выполнишь раньше, чем если задержишься'
  },
  
  // Ошибка 4: Недооцениваешь неизвестность
  underestimateUncertainty: {
    wrong: 'Я знаю этот паттерн = 3 points',
    right: 'Я никогда не делал это конкретно = 5 points',
    fix: 'Высокая неизвестность = +3 points минимум'
  }
};

7. Инструменты и методики

// Planning Poker (в команде)
const planningPoker = {
  как: [
    'Все разработчики вытягивают карточку с numbers',
    'Показывают одновременно',
    'Если разброс > 3, обсуждают'
  ],
  плюсы: [
    'Группа умнее одного человека',
    'Раскрываются разные подходы',
    'Выравнивает estimate'
  ]
};

// T-shirt sizing (для быстрых оценок)
const tShirtSizing = {
  xs: 'Тривиально < 1 hour',
  s: 'Просто = 1-2 hours',
  m: 'Средняя = 1 day',
  l: 'Сложная = 2-3 days',
  xl: 'Очень сложная = неделя',
  xxl: 'Проект в себе = месяц+'
};

// Metrics tracking
const trackEstimates = () => {
  const history = [
    { task: 'Task A', estimated: 3, actual: 4, accuracy: 75 },
    { task: 'Task B', estimated: 5, actual: 5, accuracy: 100 },
    { task: 'Task C', estimated: 8, actual: 6, actual: 113 }
  ];
  
  const avgAccuracy = history.reduce((sum, h) => sum + h.accuracy, 0) / history.length;
  console.log('Точность оценок:', avgAccuracy + '%');
  // Со временем становишься точнее
};

8. Как я оцениваю на практике

// Реальный процесс в моей голове
const myEstimationProcess = {
  // Прочитал требование
  requirement: 'Добавить темную тему',
  
  // Моя первая реакция
  firstThought: '5 points, работы на день-два',
  
  // Быстрая проверка
  quickAnalysis: {
    isDarkThemeNew: 'Нет, используем CSS variables',
    howManyComponents: '15-20 компонентов нужно обновить',
    anyNewDesign: 'Нет, уже есть макеты',
    anyBackendChanges: 'Нет, только фронт',
    testing: 'Нужно проверить все компоненты в обеих темах'
  },
  
  // Уточняю
  questions: [
    'Нужны ли тесты для каждого компонента?',
    'Сохранять выбор темы в localStorage или на сервере?',
    'Какие браузеры нужно проверить?'
  ],
  
  // Финальная оценка
  finalEstimate: 5,
  breakdown: {
    implementation: 2, // дня
    testing: 1,      // день
    buffer: 0.5      // на неожиданное
  }
};

Итоги: Ключевые принципы оценки

1. Относительная оценка (story points) точнее, чем часы
2. Реалистично, не оптимистично — оцениваешь реальный сценарий
3. Всегда +20% буфер на неожиданное
4. Высокая неизвестность = разделить задачу или сделать spike
5. Обсуждай с командой — группа видит больше
6. Отслеживай accuracy — со временем становишься точнее
7. Честно говори — лучше сказать правду сейчас, чем срывать deadline
8. Задачи > 8 points = разделить на подзадачи

Оценка трудности — это умение, которое развивается. После 100-200 задач становишься намного точнее.