Демонстрация всегда работает

Каждая демонстрация разработки с AI идёт по одной и той же траектории. Кто-то даёт модели запрос. Появляется работающее приложение. Аудитория впечатлена.

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

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

Где на самом деле живёт стоимость

Стоимость разработки программного обеспечения не сосредоточена в момент первоначального создания. Она сосредоточена на четвёртой, пятой и шестой итерации:

  • Провайдера аутентификации нужно менять, потому что изменилась цена.
  • Аналитику нужно переносить, потому что вендора купили.
  • Нужно добавить функцию, которая затрагивает три экрана, о которых исходная генерация не предполагала.
  • Систему стилизации нужно заменить, потому что дизайнер сменил направление.
  • Платёжную интеграцию нужно заменить, потому что продукт вышел на новый рынок.

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

Codebase, сгенерированная AI, под давлением изменений

Большинство codebases, сгенерированных AI, нормально переживают первое изменение. Второе изменение уже вызывает дискомфорт. К четвёртому изменению команды начинают сообщать об одних и тех же симптомах:

  • «Мы попросили AI заменить провайдера аутентификации, но он изменил 14 файлов».
  • «Refactor сломал тесты в modules, которые вообще не должны были быть связаны».
  • «Мы не можем понять, какие части системы зависят от SDK аналитики».
  • «Каждое изменение требует заново разбираться во всей codebase».

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

Почему AI codebases деградируют быстрее

Традиционные codebases тоже деградируют. Но codebases, сгенерированные AI, деградируют быстрее по конкретным причинам:

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

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

Объём усиливает связанность. AI генерирует больше кода и делает это быстрее. Больше кода со слабыми границами означает больше связанности и делает это быстрее. Преимущество в скорости превращается в ускоритель деградации.

Refactor требует глобального контекста. Модели с трудом справляются с refactor, который затрагивает всю codebase, потому что окна контекста конечны, а архитектурный замысел неявен.

Настоящая инженерная задача

Настоящая инженерная задача в AI-native разработке — не «как мне генерировать код лучше?»

Она в другом: «как мне структурировать систему так, чтобы части, сгенерированные AI, можно было менять независимо друг от друга?»

Это означает:

  • Границы, которые делают радиус воздействия предсказуемым.
  • Interfaces, которые отделяют то, что меняется, от того, что остаётся.
  • Composition roots, которые делают граф зависимостей явным.
  • Contract tests, которые проверяют точки интеграции без необходимости запускать всю систему.
  • Возможность удалить и заново сгенерировать любой module без каскадных отказов.

Долгосрочное сопровождение — структурная проблема

Никакое улучшение формулировок запросов не исправит codebase, где каждый module лезет во внутренности каждого другого module. Из архитектурной связанности нельзя выбраться с помощью запросов.

Долгосрочное сопровождение AI codebase требует той же дисциплины, которой оно требовало всегда: границ, contracts и изоляции. Разница в том, что скорость AI быстрее делает видимым отсутствие этих дисциплин. Команда, которой раньше потребовалось бы два года, чтобы собрать неподдерживаемый монолит, теперь может сделать это за два месяца.

Скорость — это подарок и ловушка. Без структуры она лишь означает, что вы раньше доберётесь до кризиса сопровождения.

Связь с AI-native архитектурой

Это центральный тезис, который я изложил в статье Stanford CS146S прав насчет AI coding. Недостающий предмет — архитектура: свободное владение инструментами без архитектурной дисциплины порождает codebases, которые быстро создаются и дорого сопровождаются.

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

Проблемой никогда не была первая версия. Проблема в том, остаётся ли дешёвой пятая.

Частые вопросы

Почему codebases, сгенерированные AI, становятся трудными в сопровождении?

AI-модели оптимизируются под текущий запрос, а не под будущие изменения. В результате появляется код, который работает, но не имеет границ, нужных для независимого изменения. Без явных архитектурных ограничений связанность накапливается быстрее, чем в codebases, написанных вручную, потому что AI генерирует больше кода и делает это быстрее.

Как не дать AI codebase деградировать со временем?

Три структурные практики: жёстко удерживать границы между modules через interfaces, которыми владеет приложение; централизовать связывание зависимостей в composition root; и запускать contract tests, которые независимо проверяют точки интеграции. Это делает стоимость изменений предсказуемой независимо от того, как код был сгенерирован.

Сложнее ли делать refactor кода, сгенерированного AI, чем кода, написанного человеком?

Не по своей природе. Но в коде, сгенерированном AI, чаще отсутствуют структурные границы, которые делают refactor безопасным, потому что модели не начинают самопроизвольно оптимизировать систему под будущие изменения. Решение — навязать эти границы до генерации, а не надеяться, что модель создаст их сама.

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

Самый большой риск — ловушка скорости: в ранней фазе вы выпускаете настолько быстро, что архитектурный долг успевает накопиться раньше, чем команда это замечает. К тому моменту, когда сопровождение становится дорогим, codebase уже слишком связана, чтобы исправить её поэтапно.