К содержанию
Владимир Павлунин

Почему AI не ускоряет разработку в 10 раз: bottleneck просто переезжает в другое место

Почему код в 10 раз быстрее не ускоряет поставку в 10 раз. Узкое место переезжает в ревью, тесты и требования. Закон Литтла, модель очередей, DORA 2024–2025 и METR с оговорками.

· опубликовано · обновлено

Короткий ответ

Почему Coding Agents не ускоряют разработку в 10 раз?

Coding Agent ускоряет один шаг — написание кода, а срок выпуска определяет самый медленный шаг всего пути от идеи до продакшена. Когда код начинает появляться за минуты, очередь переезжает к ревью, тестам, требованиям и выкладке, и система работает со скоростью нового узкого места. DORA в 2024 году оценивала связь роста использования AI с пропускной способностью поставки как слабо отрицательную, в 2025-м — уже как положительную, но со стабильностью поставки она осталась отрицательной. Реальный эффект показывает не скорость написания кода, а Lead Time от идеи до продакшена и доля неудачных изменений.

Смотреть видео ↗

Главное

  • Ускорение шага, который не является узким местом, не ускоряет систему. Написание кода после Coding Agent — обычно уже не узкое место.
  • Закон Литтла делает это арифметикой. Иллюстрация, не замер: ревью пропускает 10 pull request'ов в неделю, агенты производят 30 — через 4 недели в очереди 80, и новый PR ждёт около 8 недель.
  • В авторской модели очередей ускорение кода в 10 раз сократило медиану Lead Time примерно в 2,7 раза, а при удвоении потока задач очередь переехала к требованиям и тестам.
  • DORA 2024 оценивала связь AI с пропускной способностью как отрицательную, DORA 2025 — как положительную. Связь со стабильностью поставки в обоих отчётах отрицательная. Это корреляции на опросных данных.
  • Кроме ревью, узкое место переезжает в требования, в решения, которые агент не вправе принимать, в стенды и в окна выкладки.
  • Ускорять стоит текущее ограничение потока, а проверять это — замером Lead Time от идеи до продакшена, а не числом строк или долей кода от AI.

Об AI в разработке принято говорить цифрами: ускоряет разработчика в пять, а то и в десять раз. В написании кода я вполне готов в это поверить. Проблема в другом: разработчик пишет код в десять раз быстрее, а компания выпускает изменения почти так же медленно, как раньше.

Короткий ответ. Coding Agent ускоряет один шаг — код. Срок выпуска задаёт самый медленный шаг всего пути от идеи до продакшена. Когда код появляется за минуты, очередь переезжает к ревью, тестам, требованиям и выкладке. Система продолжает работать со скоростью узкого места — просто теперь это другое место. Узкое место я дальше называю привычным словом bottleneck.

Код за минуты: что я увидел в эксперименте

В выпуске «От Coding Agent к AI Development Platform» я отдал агенту обычную бизнес-задачу: добавить в сервис доставки интернет-магазина самовывоз из пунктов выдачи партнёра. Сервис синтетический, собран специально для эксперимента. Модель одна — claude-sonnet-5, агент — Claude Code. 3 прогона только с задачей и репозиторием (условие A), 3 — с пакетом инженерного контекста (условие B).

Цифры по шагу «код» впечатляют:

  • каждый прогон занял от 4 минут 22 секунд до 9 минут 7 секунд;
  • стоил от 0,80 до 1,85 доллара;
  • во всех 6 прогонах агент написал собственные тесты, и все они были зелёными.

Если считать только этот шаг, ускорение действительно кратное: изменение такого масштаба человек делает не за пять минут. Но дальше начинается остальной путь. Независимая приёмка по требованиям дала прогонам без контекста от 2 до 4 проверок из 10 — подробно это разобрано в статье о том, почему зелёные тесты от AI ещё не значат, что задача решена. Агент-ревьюер за 81 секунду и 25 центов нашёл в одном из этих прогонов 3 блокера и вынес вердикт «мержить нельзя».

То есть код появился за минуты, а до продакшена ему ещё предстоит ревью, исправления, повторная проверка, проверка безопасности и выкладка. Всё это эксперимент не ускорял.

Оговорка, которую я повторяю в каждом материале по этому выпуску: 6 прогонов, один синтетический репозиторий, одна модель, проверки писал я. Это демонстрация механизма, а не бенчмарк.

Из чего на самом деле состоит Lead Time

Путь обычного изменения:

идея → требования → архитектура → код → тесты → ревью → безопасность → поставка → продакшен

Время прохождения всего пути — Lead Time. У него две составляющие, которые важно не путать:

  • время работы — кто-то действительно занимается задачей;
  • время ожидания — задача лежит в очереди: ждёт ответа бизнеса, свободного разработчика, ревьюера, стенда, релиза.

В трекере почти любой команды ожидание оказывается длиннее работы. Coding Agent сокращает время работы на одном шаге. Очереди он сам по себе не трогает — а на следующих шагах может их удлинить.

При неизменном ожидании эффект от ускорения шага не больше его доли в полном времени. Шаг, который занимает пятую часть пути, даже при бесконечном ускорении сократит путь только на эту пятую часть. В системе с очередями всё сложнее: ускорение одного шага меняет ожидание перед следующими. Поэтому итог стоит не прикидывать, а считать.

Теория ограничений: ускорили не то

Идея старая. Элияху Голдратт в книге «Цель» (1984) сформулировал её так, если пересказывать: выход системы определяется её узким местом, и время, сэкономленное на шаге, который узким местом не является, выход системы не увеличивает.

Пока код писали люди, узким местом часто и был код: задачи ждали свободного разработчика. Coding Agent это место действительно разгружает. Но следующий шаг — ревью, тестирование, приёмка — работает с прежней скоростью. И теперь он узкое место.

Закон Литтла: арифметика очереди на ревью

В теории очередей есть закон Литтла:

L = λ · W

L — сколько незавершённой работы в системе
λ — пропускная способность (сколько работы проходит за единицу времени)
W — среднее время, которое единица работы проводит в системе

Отсюда W = L / λ: при той же пропускной способности больше работы в очереди означает дольше путь каждой задачи.

Пример, не замер. Цифры условные, чтобы показать механизм.

ревью пропускает        10 PR в неделю
агенты производят       30 PR в неделю
очередь растёт на       20 PR в неделю

через 4 недели          в очереди 80 PR
новый PR ждёт           80 ÷ 10 = 8 недель

Код написан за 5 минут. До продакшена — около двух месяцев, даже если этот pull request идеален: просто перед ним очередь.

Честная оговорка. Закон Литтла строго выполняется для устойчивой системы в среднем. Очередь, которая растёт каждую неделю, — как раз неустойчивая система, и в ней ожидание будет расти, пока кто-то не изменит правила: не добавит ревьюеров, не ограничит приток или не автоматизирует часть проверки. Арифметика «80 ÷ 10» — это время разбора уже накопленной очереди, а не прогноз для вашей команды. Но интуиция закона работает: пока пропускная способность следующего шага не выросла, производить больше на предыдущем — значит удлинять путь каждой задачи.

Модель очередей: что происходит со всем конвейером

Пример с ревью — один шаг. Чтобы посмотреть на весь путь, я собрал простую имитационную модель конвейера. Это модель, а не замер в компании: параметры условные, важно поведение системы, а не значения.

Как устроена модель:

  • 7 этапов по порядку, на каждом одна «полоса»: задачи обрабатываются по очереди, без параллельных исполнителей и без возвратов на доработку;
  • среднее время работы: требования — 1 день, архитектура — 0,5, код — 2, тесты — 1, ревью — 0,8, безопасность — 0,5, CI/CD и выкладка — 0,3. Итого 6,1 дня чистой работы;
  • задачи приходят неравномерно (пуассоновский поток), длительность работы плавает (гамма-распределение, разброс — половина от среднего);
  • в каждом сценарии 6000 задач, первая тысяча отбрасывается как разгон;
  • Lead Time считается от появления задачи в очереди перед требованиями до выкладки.
Сценарий Выпуск, задач в день Lead Time, медиана Lead Time, 85-й перцентиль Где стоит ожидание (среднее)
A. До AI: код — 2 дня, поток 0,45 задачи в день 0,45 13,6 дня 30,5 дня перед кодом — 11,4 дня
B. Код в 10 раз быстрее, поток прежний 0,45 5,1 дня 6,9 дня требования — 0,5, тесты — 0,3
C. Код в 10 раз быстрее, поток вдвое больше 0,90 11,9 дня 22,8 дня требования — 6,2, тесты — 2,8

Результаты авторской имитационной модели, не замеры команд. Среднее ожидание и медиана полного времени — разные статистики, складывать их нельзя.

Что видно:

  • B. Код ускорился в 10 раз, медиана Lead Time — в 13,6 / 5,1 ≈ 2,7 раза. Чистая работа сократилась с 6,1 до 4,3 дня, основной выигрыш дало исчезновение очереди перед кодом. Выпуск не вырос: задач приходит столько же.
  • C. Команда берёт вдвое больше задач. Выпуск вырос вдвое — это реальный результат. Но медиана Lead Time почти вернулась к исходной: 11,9 дня против 13,6. Очередь переехала — вверх, к требованиям, и вниз, к тестам.
  • Потолок. После ускорения кода самые медленные этапы — требования и тесты, по дню на задачу. Предел пропускной способности модели — 1 задача в день, то есть 1 / 0,45 ≈ 2,2 от исходного выпуска, сколько бы кода ни писал агент. И работать у самого предела нельзя: при неравномерном потоке очереди растут без ограничения.

При подготовке этого обновления я пересчитал модель с теми же параметрами на 10 разных случайных потоках. Сценарий B стабилен: медиана 5,0–5,1 дня. В сценариях A и C самый загруженный этап занят на 90%, и медиана заметно гуляет: примерно от 12 до 17 дней в A и от 10,5 до 15 в C. Поэтому сравнивать стоит порядок величин и направление, а не десятые доли.

Что говорят данные: DORA 2024 → 2025, METR

DORA 2024. Исследование DORA оценило: при росте использования AI на 25% пропускная способность поставки снижалась примерно на 1,5%, а стабильность — примерно на 7,2%. Объяснение DORA — с AI растёт размер пакетов изменений, а большие пакеты повышают риск. Важно, что это модельная оценка на опросных данных, а не эксперимент.

DORA 2025. Через год картина изменилась: связь использования AI с пропускной способностью стала положительной, а со стабильностью поставки — осталась отрицательной. Отрицательная связь со стабильностью сохраняется там, где нет сильных систем контроля — автотестов, контроля версий, быстрой обратной связи. Главный вывод отчёта: AI — усилитель, он не чинит команду, а усиливает то, что в ней уже есть.

Как я это читаю: писать код с AI команды научились быстрее, а проверять и безопасно выпускать больший объём изменений — нет. Это ровно картина переехавшего узкого места. Но это моя интерпретация корреляций, а не вывод DORA.

Faros AI, 2025. Вендорский отчёт по телеметрии более 10 000 разработчиков: в командах с высоким использованием AI сливают на 98% больше pull request'ов, но время ревью выросло на 91%, а размер PR — на 154%. Значимой связи с улучшениями на уровне компании авторы не нашли. Это корреляция и отчёт компании, которая продаёт аналитику продуктивности, — но направление совпадает с DORA.

METR, 2025–2026. В рандомизированном эксперименте начала 2025 года 16 опытных разработчиков в своих зрелых репозиториях с AI-инструментами решали задачи на 19% дольше — и при этом считали, что ускорились примерно на 20%. Эту цифру нельзя выдавать за «AI замедляет разработчиков»: выборка маленькая, инструменты — начала 2025 года, а в феврале 2026 METR сам сообщил, что новые данные показывают небольшое ускорение, но искажены эффектом отбора: 30–50% разработчиков не хотели брать задачи без AI. METR меняет дизайн исследования.

Что я беру из METR — разрыв между ощущением и измерением. Если эффект оценивать по ощущениям команды, можно ошибиться даже в знаке. Отсюда и главный практический вывод статьи: мерить нужно путь задачи, а не впечатление.

Почему растёт риск: размер пакета

DORA объясняет падение стабильности размером изменений. Писать код стало дёшево, и в один pull request попадает больше. Faros видит то же в телеметрии: PR крупнее в 2,5 раза.

Большой пакет изменений труднее проверить, труднее откатить и сложнее понять, что именно сломалось. Он удлиняет ревью — то есть бьёт как раз по новому узкому месту. Работа малыми пакетами — одна из 7 возможностей в модели DORA, которые усиливают эффект от AI.

Куда ещё переезжает bottleneck

Ревью — самое заметное новое узкое место, но не единственное. Когда код становится дешёвым, очередь может встать в нескольких местах.

Ревью. Изменений больше, они крупнее, ревьюеры те же. У ревьюера нет истории того, как рождалось решение. Соблазн — смотреть по диагонали, и тогда вместо очереди вы получаете дефекты в продакшене.

Тесты и приёмка. Агент пишет тесты к своему коду, и они зелёные — но проверяют его собственное понимание задачи. В эксперименте тест агента закрепил бесплатную доставку, которой в требованиях не было. Нужна независимая приёмка, и она тоже требует времени.

Требования. Весь эксперимент держался на одном документе — требованиях к самовывозу: 6 бизнес-правил, по строке на каждое. Без него агент в 3 прогонах выбрал 3 разные цены, и ни одна не совпала с утверждённой, — подробнее в статье о том, почему агенту недостаточно репозитория. Если в требованиях ошибка, агент с контекстом реализует её идеально. Разработка «съедает» задачи быстрее, чем их успевают сформулировать, — это же показала и модель в сценарии C.

Решения. Кто-то должен был решить, что самовывоз стоит 99 рублей. Агент такие решения не принимает — он их либо исполняет, либо выдумывает. Очередь к людям, которые принимают бизнес- и архитектурные решения, растёт вместе со скоростью кода. Отчасти её снимает context engineering: решения, которые уже приняты, должны доходить до агента.

Безопасность. Код, который никто не писал руками, требует не менее внимательной проверки, а более. Если безопасность — ручной этап в конце, он становится ограничением.

Среда. Стенды, данные для тестов, окна выкладки. Если стенд один на всю команду, 10 агентов будут стоять в очереди к нему. Релизы «поездом» раз в две недели делают бессмысленной разницу между двумя днями и пятью минутами на код.

Схема: куда уходит очередь

ДО: узкое место — код

идея → требования → [ОЧЕРЕДЬ] → код → тесты → ревью → поставка → продакшен


ПОСЛЕ: код за минуты, очередь переехала

идея → [очередь] → требования → код → [ОЧЕРЕДЬ] → тесты, ревью → [очередь] → поставка → продакшен
          │                            │                        │
   не успевают                  проверка не успевает      общий стенд,
   формулировать                за объёмом кода           окно релиза

Ограничения

  • Пример с законом Литтла — иллюстрация с условными цифрами, не замер.
  • Модель очередей упрощена: одна полоса на этапе, нет возвратов, нет роста размера изменений. Возвраты с ревью и приёмки в реальности удлинили бы путь ещё сильнее.
  • DORA и Faros — корреляции на опросных данных и телеметрии, причинность они не доказывают. Faros — вендорский отчёт.
  • METR — маленькая выборка, результат 2025 года сам METR в 2026 году пересмотрел.
  • Мой эксперимент — 6 прогонов на синтетическом репозитории. Он показывает, что код стал дешёвым, а проверка — нет, но не измеряет Lead Time реальной команды.

Что делать

Общий принцип: подключать AI и менять процесс не там, где инструмент выглядит эффектнее, а там, где сейчас стоит очередь.

  1. Измерить путь. Lead Time от идеи до продакшена и ожидание на каждом этапе. Не от первого коммита — иначе требования и решения выпадают из картины. Что именно считать и чего не считать, я разобрал в статье о метриках AI-разработки.
  2. Ограничить незавершённую работу. Если очередь на ревью больше лимита, агенты не начинают новые задачи, а помогают закрывать старые.
  3. Резать изменения. Задачу для агента нарезают так же, как для человека: одно изменение — один небольшой pull request.
  4. Автоматизировать проверку, которая не требует человека. Приёмочные тесты из требований, архитектурные правила, сканеры безопасности — в конвейере. Человек смотрит смысл, риски и то, что политика отметила как рискованное.
  5. Разгрузить требования и решения. Решения, которые уже приняты, должны доходить до агента как контекст, а не жить в головах.
  6. Проверить результат замером. Если после внедрения агентов Lead Time не сократился, значит, вы ускорили не тот шаг.

Это и есть переход от отдельного Coding Agent к системе вокруг него — я описываю её в статье об AI Development Platform.

Понять, на каком этапе AI даст эффект в вашем процессе, а на каком упрётся в следующий, помогает бесплатный AI Engineering Assessment: профиль по семи измерениям, возможные ограничения и шаги на 30 и 90 дней. Результат — сразу, без регистрации. Это ориентировочная диагностика, а не аудит: узкое место потока после неё стоит подтвердить замером задач.

Пройдите бесплатный AI Engineering Assessment

Источники

  • Announcing the 2024 DORA report (Accelerate State of DevOps 2024). Google Cloud / DORA, 2024.
  • Announcing the 2025 DORA Report: State of AI-assisted Software Development. Google Cloud / DORA, 2025.
  • Introducing DORA's inaugural AI Capabilities Model. Google Cloud / DORA, 2025.
  • The AI Productivity Paradox Report 2025. Faros AI, 2025.
  • Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. METR, 2025.
  • We are Changing our Developer Productivity Experiment Design. METR, 2026.
  • John D. C. Little. A Proof for the Queuing Formula: L = λW. Operations Research, INFORMS, 1961.
  • Eliyahu M. Goldratt, Jeff Cox. The Goal: A Process of Ongoing Improvement. North River Press, 1984.
  • Эксперимент выпуска «От Coding Agent к AI Development Platform»: 6 прогонов Claude Code (claude-sonnet-5) на синтетическом сервисе доставки. Владимир Павлунин, 2026.
  • Имитационная модель конвейера разработки. Владимир Павлунин, 2026.

Вопросы и ответы

Правда ли, что AI ускоряет разработчика в 10 раз?

В написании кода на хорошо описанной задаче кратное ускорение возможно. В моём эксперименте агент делал изменение для сервиса доставки за 4–9 минут. Но контролируемые данные скромнее и противоречивее громких цифр, а главное — разработка не сводится к коду. Требования, ревью, проверка безопасности и выкладка остаются с прежней скоростью.

Куда переезжает bottleneck после внедрения Coding Agent?

К следующему самому медленному шагу. Чаще всего это code review — изменений больше, они крупнее, а ревьюеры те же. Но очередь может встать и перед тестами, и перед требованиями, и перед общим стендом, и перед окном релиза. Где именно, показывает замер ожидания на каждом этапе.

Причём здесь закон Литтла?

Он связывает объём незавершённой работы, пропускную способность и время в системе — L = λW. Если работы в очереди на ревью становится больше, а ревью пропускает столько же, время ожидания каждой задачи растёт. Строго закон описывает устойчивую систему в среднем, поэтому пример с растущей очередью в статье — иллюстрация, а не расчёт для конкретной команды.

Доказала ли DORA, что AI замедляет поставку?

Нет. В 2024 году DORA дала модельную оценку на опросных данных — небольшое снижение пропускной способности и более заметное снижение стабильности при росте использования AI. В отчёте 2025 года связь с пропускной способностью стала положительной, а со стабильностью осталась отрицательной. Это корреляции, а не эксперимент.

А исследование METR, где разработчики с AI работали на 19% медленнее?

Это 16 опытных разработчиков и инструменты начала 2025 года. В феврале 2026 METR сам сообщил, что новые данные показывают небольшое ускорение, но им мешает эффект отбора, и изменил дизайн исследования. Из этой работы я беру другой урок — ощущение ускорения и измеренное время могут сильно расходиться.

Значит, Coding Agents не нужны?

Нужны. Они действительно убирают узкое место на написании кода. Но это первый шаг — эффект для бизнеса появляется, когда следом перестраивают проверку, требования и поставку.

С чего начать команде, которая уже пользуется агентами?

С замера. Возьмите 20–30 сопоставимых завершённых задач и выпишите, сколько каждая провела на каждом этапе и сколько из этого времени ждала. Самый длинный отрезок ожидания — первый кандидат на изменение.

Читать дальше

СтатьяEngineering Management Метрики AI-разработки: чем измерять эффект Coding Agents, если не строками кода Чем измерять эффект AI и Coding Agents в разработке. Почему строки кода, токены и доля кода от AI не показывают результат, и какие метрики потока, качества и стоимости работают. 17 октября 2026 Читать → СтатьяAI Development AI написал код и тесты, всё зелёное — почему задача всё ещё не решена Coding Agent написал код и 20 тестов, все зелёные, — а независимая приёмка по требованиям прошла 4 из 10. Разбираем на реальном эксперименте, почему тесты автора закрепляют его догадки, как устроить независимую приёмку и ревью и почему отчёт агента — не доказательство. 13 октября 2026 Читать → СтатьяAI Development От Coding Agent к AI Development Platform: почему быстро написать код недостаточно Эксперимент на 6 прогонах: агент пишет код за минуты, но без контекста, прав и проверок решает не ту задачу. Из чего состоит AI Development Platform. 1 октября 2026 Читать → Главный материалСтатьяAI Development AI в цикле разработки — что это и как внедрять Что такое AI Development, из чего состоит AI Development Platform и с чего начинать внедрение AI в разработку — от требований до delivery. 20 сентября 2026 Читать →