Почему 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 и менять процесс не там, где инструмент выглядит эффектнее, а там, где сейчас стоит очередь.
- Измерить путь. Lead Time от идеи до продакшена и ожидание на каждом этапе. Не от первого коммита — иначе требования и решения выпадают из картины. Что именно считать и чего не считать, я разобрал в статье о метриках AI-разработки.
- Ограничить незавершённую работу. Если очередь на ревью больше лимита, агенты не начинают новые задачи, а помогают закрывать старые.
- Резать изменения. Задачу для агента нарезают так же, как для человека: одно изменение — один небольшой pull request.
- Автоматизировать проверку, которая не требует человека. Приёмочные тесты из требований, архитектурные правила, сканеры безопасности — в конвейере. Человек смотрит смысл, риски и то, что политика отметила как рискованное.
- Разгрузить требования и решения. Решения, которые уже приняты, должны доходить до агента как контекст, а не жить в головах.
- Проверить результат замером. Если после внедрения агентов 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 сопоставимых завершённых задач и выпишите, сколько каждая провела на каждом этапе и сколько из этого времени ждала. Самый длинный отрезок ожидания — первый кандидат на изменение.