Сейчас часто можно услышать мнение, что LLM и AI-агенты способны значительно снизить стоимость разработки. Вместо того чтобы расширять команду, достаточно дать задачу модели, и она выполнит работу за минуты.

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

Как раньше масштабировался технический долг

Долгое время развитие большинства крупных проектов выглядело примерно одинаково:

Технический долг
→ снижение скорости разработки
→ расширение команды
→ рост коммуникаций
→ увеличение количества регрессий
→ еще больше технического долга.

Когда система становилась слишком сложной, компания начинала нанимать все больше разработчиков (часто джуниоров, чтобы подешевле). Но при этом каждый новый человек к команде увеличивал количество коммуникаций, усложнял процессы и всё это, постепенно, приводило к снижению общей скорости разработки.

В результате технический долг не уменьшался. Компания просто платила за него большим количеством инженеров (пока была возможность).

Что изменилось с появлением LLM

Сегодня меняется не сама проблема, а стоимость одного из ресурсов.

Вместо того чтобы нанять еще пять разработчиков, компания может «нанять» в тысячу раз больше вычислений.

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

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

Но фундаментальная проблема остается прежней.

LLM не устраняет сложность системы.

Поэтому я бы сформулировал это так:

Раньше технический долг оплачивали людьми. Теперь его можно некоторое время оплачивать токенами. Но технический долг никуда не исчезает – он просто меняет валюту.

Почему стоимость разработки все равно начинает расти

На мой взгляд, есть несколько причин, почему этот процесс приводит практически к тем же последствиям.

Контекст становится все дороже

Чем сложнее проект, тем больше файлов, зависимостей, бизнес-логики и исторического контекста необходимо предоставить модели.

Стоимость решения одной задачи постепенно начинает расти не из-за сложности самой задачи, а из-за стоимости понимания системы.

Падает качество понимания

LLM великолепно работают в хорошо структурированных проектах. Но скажите честно, вы часто видели такие в энтерпрайзе?

Поэтому, если кодовая база состоит из огромных сервисов, циклических зависимостей, неявных побочных эффектов и десятков архитектурных компромиссов, модели приходится тратить значительно больше вычислений на понимание происходящего.

Одновременно увеличивается вероятность ошибок.

Возрастает стоимость проверки

Даже если код был написан за несколько секунд, его необходимо проверить, протестировать и безопасно интегрировать.

Если архитектура проекта плохая, стоимость верификации начинает расти быстрее, чем скорость генерации.

Именно поэтому ускорение написания кода далеко не всегда приводит к ускорению поставки изменений в проде.

Регрессии никуда не исчезают

Если система плохо разбита на модули (или не разбита вообще) и недостаточно покрыта тестами, AI способен производить регрессии даже быстрее человека.

Причина очень проста.
Он генерирует значительно больше кода за единицу времени.

Чем больше изменений вносится в сложную систему, тем выше вероятность появления новых ошибок.

Почему проблему стало сложнее заметить

Здесь появляется важное отличие от прошлых лет.

Раньше компании были ограничены количеством инженеров и бюджетом на найм. Сегодня ограничение выглядит менее очевидным.

Вместо увеличения команды компания начинает постепенно увеличивать расходы на инференс, агентные циклы, повторные генерации, дополнительные проверки, автоматическое создание тестов и другие AI-инструменты.

Со стороны кажется, что производительность остается высокой. На практике же стоимость каждой следующей задачи постепенно увеличивается.

Проблема просто оказывается лучше замаскирована.

Главный дефицит эпохи AI

Мне кажется, самый интересное здесь это то, что проблема вообще не связана со стоимостью токенов.

Главный дефицит эпохи AI – это не скорость генерации кода.

Это архитектурная энтропия.

LLM отлично масштабируют производство кода.
Но они почти не уменьшают сложность самой системы.

Если архитектура становится слишком сложной для человека, постепенно она становится слишком сложной и для AI.

В этот момент стоимость каждой новой задачи начинает расти уже не линейно, а экспоненциально.

Причем совершенно неважно, чем измеряются затраты – зарплатами разработчиков или миллионами сожженных токенов.

Возможно, это один из законов эпохи AI

Я бы сформулировал его так:

Любой технический долг, который раньше требовал линейного роста команды, теперь сначала потребует линейного роста потребления токенов, а затем приведет к тому же результату – экспоненциальному росту стоимости изменений. Разница лишь в том, что ограничением становится не количество инженеров, а стоимость и объем вычислений, необходимых для понимания системы.

Если эта гипотеза верна, то главным конкурентным преимуществом в эпоху AI станет уже не способность быстрее генерировать код.

Главным преимуществом станет способность поддерживать архитектуру достаточно простой, чтобы ее одинаково хорошо понимали и человек, и AI.

Именно это, IMHO, станет настоящим ограничением разработки в ближайшие годы.