ИИ заставляет программную инженерию заново открыть алгоритмы

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

Но недавние эксперименты с ИИ-агентами показали неожиданную вещь: написать код относительно легко. Намного сложнее поддерживать программную систему, когда она начинает эволюционировать.

Возможно, причина в том, что современные программы постепенно теряют то, что когда-то было их центром — алгоритм.

Недавно исследователи из Alibaba Group провели эксперимент с агентами искусственного интеллекта для программирования.

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

На первых шагах всё выглядело обнадёживающе.

ИИ-агенты:

Но спустя несколько десятков коммитов произошло нечто неожиданное.

Системы начали деградировать.

Появлялись ошибки регрессии. Ломались зависимости. Постепенно разрушалась архитектурная целостность системы.

Чем больше изменений вносили агенты, тем сложнее становилось поддерживать систему.

Эксперимент показал довольно неприятную вещь:

написать код относительно легко. Гораздо сложнее поддерживать систему во времени.

Самое простое объяснение — современные модели ИИ ещё недостаточно хороши.

Но такое объяснение слишком поверхностно.

На самом деле эти эксперименты показывают более глубокую проблему.

ИИ не ломает наши программы.

Он лишь обнаруживает структурную слабость, которая уже существовала.

Современные программные системы часто скрывают то, что должно направлять их развитие:

алгоритм.

В классической информатике алгоритм был центральным элементом программы.

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

Однако за последние десятилетия программная инженерия постепенно сместилась в другую сторону.

Сегодня системы всё чаще строятся вокруг:

В результате возникает кодовая база, в которой алгоритм перестаёт быть явно видимым.

Он оказывается:

С точки зрения как человека, так и машины алгоритм становится трудно различимым.

Фактически можно сказать, что алгоритм постепенно исчезает из программы.

Чтобы описать эту структурную разницу, можно использовать простую метафору.

Представим два типа программ.

В программе-бублике алгоритм образует пустоту в центре.

Код окружает эту пустоту, но сам алгоритм не представлен явно.

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

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

Именно так устроено большинство современных программных систем.

В программе-маффине алгоритм представлен явно.

Он существует как отдельная структурная сущность.

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

Когда система развивается, изменения происходят вокруг алгоритма, а не внутри него.

Такие системы значительно проще:

Если сформулировать это совсем коротко, получается простое правило:

Программа-бублик — это программа, где алгоритм приходится восстанавливать из кода.

Программа-маффин — это программа, где код реализует явно существующий алгоритм.

Именно поэтому сопровождение программ-бубликов со временем становится всё труднее — как для людей, так и для ИИ.

ИИ-агенты терпят неудачу не потому, что не умеют программировать.

Они терпят неудачу потому, что мы дали им бублики вместо маффинов.

В индустрии давно обсуждают понятие технического долга.

Но эксперименты с ИИ показывают более глубокую проблему.

Можно назвать её методологическим долгом.

Технический долг возникает, когда код становится неаккуратным.

Методологический долг возникает тогда, когда структура системы скрывает алгоритм.

Человеческие разработчики иногда способны компенсировать это за счёт опыта и интуиции.

ИИ-агенты такой возможности не имеют.

Если алгоритм невидим, любое изменение может нарушить систему.

Фактически агент пытается ориентироваться по карте без ориентиров.

Долгое время разработка программного обеспечения опиралась на человеческую интуицию.

Разработчики могли понимать систему даже тогда, когда её структура была далека от идеальной.

Но ситуация меняется.

Если в эволюции программ начинают участвовать ИИ-агенты, система должна быть понятна не только людям, но и ИИ-агентам.

Это может привести индустрию к довольно простому выводу:

программные системы должны явно представлять свои алгоритмы.

Возможно, нас ждёт возвращение к алгоритмо-центричным подходам.

В таких системах:

Такой подход не просто делает систему более понятной.

Он может оказаться необходимым условием для надёжной разработки с участием ИИ.

Многие годы индустрия оптимизировала скорость написания кода.

ИИ делает эту задачу почти тривиальной.

Но одновременно он показывает более глубокую проблему:

способны ли наши системы эволюционировать, не разрушаясь под давлением постоянных изменений?

Если нет, программной инженерии, возможно, придётся вернуться к одному из своих самых старых оснований:

алгоритму.

Но не как к абстрактной концепции из учебников.

А как к явной структуре, которая направляет жизнь программной системы.

Программная инженерия десятилетиями оптимизировала процесс написания кода.

ИИ делает эту задачу почти тривиальной.

Но одновременно он показывает то, что мы долго не замечали.

ИИ не ломает наши программы. Он показывает, что алгоритмы внутри них постепенно исчезают.

Если эпоха ИИ изменит программную инженерию, то, возможно, не новыми инструментами.

А тем, что она заставит нас снова поставить алгоритм в центр программной системы.

Если всё больше изменений в программные системы будут вносить ИИ-агенты, должны ли сами системы быть устроены так, чтобы их алгоритмы были явно видны и служили ориентиром для эволюции?

Или исчезновение алгоритма из кода — это неизбежная цена масштабирования современной разработки?

Как вы думаете?

Метафора программ-бубликов и программ-маффинов была предложена в моих более ранних работах по эко-программированию и алгоритмо-центричным методологиям разработки. Она описывает, остаётся ли алгоритм в центре системы (маффин/коржик) или растворяется в окружающем коде (бублик/бэгел).