Преодолевая звуковой барьер в разработке ПО с ИИ

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

Введение

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

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

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

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

Это и есть наш звуковой барьер.

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

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

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

Неопределённость требований

Распишем проблему запросов/описания решений. Рассмотрим множество поведений перед принятием решения:

Рис. 1. Пока требования не сформулированы, всё пространство поведения остаётся неопределённым. Рис. 1. Пока требования не сформулированы, всё пространство поведения остаётся неопределённым.

Здесь одна точка квадрата это один вариант поведения системы — например, конкретные тестовые данные на входе, и поведение на выходе. Темно-серый цвет — относительно спецификаций поведение не определено, поэтому реализация может быть любой для такой точки. У нас все в таком цвете потому как запроса еще нет, то есть, до постановки задачи еще нет ограничений на поведение системы, поэтому любое поведение будет считаться корректным.

Когда мы формулируем задачу, например «напиши клиента который проведет HTTP-запрос по указанному URL и заберет данные», то мы определяем желаемое поведение для определенных условий. В данном случае если все хорошо и ничего не сломалось, то данные должны быть забраны (А). Выглядит это так:

Рис. 2. Требование A задаёт успешное получение данных; поведение в остальных случаях не определено. Рис. 2. Требование A задаёт успешное получение данных; поведение в остальных случаях не определено.

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

Далее, добавим в требования «если получен ответ 500, то сделай повтор через 10 секунд» (B). В этом случае ситуация становится лучше, так как мы детерминируем и специфицируем серое поведение, а главное — мы ставим это под контроль. В этом случае мы уже можем написать тесты, статический анализ получает основу для разбора, ревьювер может сказать что не соответствует спецификации (про серое такое он сказать не может), и т.д. В то же время картинка меняется на такую:

Рис. 3. Требование B добавляет повтор через 10 секунд при ответе 500; остальные случаи остаются неописанными.Рис. 3. Требование B добавляет повтор через 10 секунд при ответе 500; остальные случаи остаются неописанными.

Мы определили что делать когда все хорошо (А) и как реагировать на 500 (B). Но это не исключает всю серую зону. И, если выдать такое задание в работу, то результат может выглядеть так:

Рис. 4. Реализация заполняет неопределённые области конкретным поведением, включая дополнительный вариант C. Рис. 4. Реализация заполняет неопределённые области конкретным поведением, включая дополнительный вариант C.

Разберем что тут происходит. Разработчик выбирает какую-то реализацию на свое усмотрение, и допустим что он все сделал правильно относительно A и B (но не факт, так как могут быть ошибки). Реализация обладает конкретным поведением в каждом случае и не может быть серой. Но она должна определить каждую точку с ее поведением. Например, если делать повтор на любую ошибку, то это будет корректное поведение относительно запроса, так как для ошибки 500 это верно, а для других ошибок не определено. Но в то же время, реализация может отправлять на повтор и ошибки >500, и тогда B-поведением становится не только 500, но и >500.

На картинке показана область (С), — это может быть поведение которое не описано явно в запросе, например останов приложения в случае выбрасывания исключения.

Но что происходит относительно разработчика. Один разработчик пойдет на Stack Overflow и скопирует оттуда пару строк. Другой может посмотреть примеры рядом в проекте. Третий уже сто раз так делал и сделает по-своему. ИИ-помощник не исключение: возможно, он постарается сэкономить токены, а возможно, проведёт какую-то внутреннюю самопроверку. Но в любом случае мы получаем различный спектр решений. И если над этими решениями нет контроля, конечная реализация будет случайно плавать.

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

Накопление локальных решений

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

Например, задание звучит как «напиши клиента который проведет HTTP-запрос про указанному URL и заберет данные». В этом случае что человек, что ИИ-помощник могут написать несколько строк кода, которые это выполнят:

const response = await fetch('https://api.example.com/data');const data = await response.json();

(прим. тут код может быть на любом языке и статья написана без привязки к какому-либо языку, платформе или ИИ-модели)

И к такому решению сложно придраться — оно буквально выполняет ровно то что потребовалось. Однако, в больших и сложных проектах это зачастую не совсем то что нужно. В частности, оно не отвечает на вопрос как поведет себя система в случае, если что-то пошло не так — например пришел ответ не 200 или произошел таймаут соединения. Такое решение не учитывает работающее окружение (корректность данных, доступность сервера, производственные возможности приложения и др.).

На практике более опытный инженер увидев такое решение может спросить разработчика, будь то человек или ИИ-модель, «а как поведет себя система если произойдет такая-то проблема?» И тут в ответ может прозвучать «Ой!» и эта пара строк кода начнет обрастать обработчиком предъявленной ошибочной ситуации.

Рассмотрим ту же ситуацию с другой стороны. В работающую систему пришло сообщение об ошибке. Как правило это сообщение точечное вида «клиент делает X, получает Y, а ожидается Z». Это преобразуется в задачу вида «Если X то надо сделать так, чтобы было Z». Как видим, это требование точечное, оно очень похоже на одиночный вопрос «а что если …?» заданный выше.

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

Рис. 5. Хорошо построенная система до начала накопления локальных изменений. Рис. 5. Хорошо построенная система до начала накопления локальных изменений.

Неровностей не видно, ошибок и проблем тоже. Но в какой-то момент возникает новое требование или обнаруживается ошибка. Если правки вносятся методом, описанным выше, то это преобразование выглядит так:

Рис. 6. Локальная проблема устраняется заплаткой. Рис. 6. Локальная проблема устраняется заплаткой.

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

Рис. 7. Накопление локальных решений превращает систему в мозаику перекрывающихся заплаток. Рис. 7. Накопление локальных решений превращает систему в мозаику перекрывающихся заплаток.

И наша хорошо построенная изначально система превращается вот в такую неровную мозаику.

Проблема которая возникает из-за мозаичности подобна отсутствию структурного подхода во время программирования или проектирования. На более низком уровне мы получаем спагетти-код. На практике даже если хорошее покрытие тестами, то его сложно сопровождать — каждый новый запрос приводит к тому, что нужно проверять и контролировать множество зависимостей. Это известно еще со времен Дейкстры и Хоара — если не структурировать систему на более высоком уровне, то мы получаем как дополнительный источник ошибок, так и дополнительную сложность для отладки, анализа и верификации.

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

Рис. 8. Структуризация на более высоком уровне заменяет группу локальных решений общей абстракцией. Рис. 8. Структуризация на более высоком уровне заменяет группу локальных решений общей абстракцией.

Таким образом, накопление локальных решений означает, что мы постепенно теряем контроль над тем, как это устроено.

Тут есть ряд вариантов решения проблемы, и они могут быть разного уровня и масштабности. Но общий подход — необходимо периодически осматривать происходящее и принудительно структурировать, в том числе с ИИ-помощником. Для описанного случая можно рассмотреть такие принципиально разные варианты:

  • просто задать вопрос ИИ: «проанализируй поведение если пришла та или иная ошибка (4хх, 5хх, обрыв, …) и другие ошибочные ситуации (например таймаут)»;

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

  • вопрос вида «вот у нас три класса, давай подумаем что у них общего и можно ли что-то вынести в базовый»

  • описание пред-/пост- условий и инвариантов.

Могут быть и другие более обобщающие архитектурные решения, о которых мы поговорим дальше.

Контроль проектных знаний

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

src/ controllers/ services/ repositories/

Это может говорить о том, что использовалась трёхслойная архитектура Three-Layer Architecture (3LA), но неясно правда ли это и насколько широко она применялась, и какие у нее границы. Помимо факта применения, остаются открытыми вопросы:

  • Где заканчивается ответственность контроллера и начинается ответственность сервиса?

  • Допустимо ли обращаться к репозиторию непосредственно из контроллера?

  • На каком уровне определяются границы транзакций?

  • Где выполняются авторизация, валидация и сериализация?

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

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

Особенность в том что ИИ-помощник находится в подобной ситуации. По сути, когда мы с нуля запускаем агента, то это отрабатывает так, если бы мы нанимали случайного программиста из всей индустрии со своими особенностями и отправляем его в бой. И, если его не проинструктировать, то он будет действовать по своему усмотрению. А если он видит только код, то мы получим соответствующие последствия. При этом даже одна и та же модель в разных сессиях может вести себя как несколько разработчиков с разными привычками. Один агент выбирает одну декомпозицию, другой — другую. Один следует существующим именованиям и соглашениям, другой привносит свои. Третий обнаруживает архитектурную закономерность, но трактует её иначе, чем предполагали авторы системы. Они все могут написать рабочий код, но без инструкций они выбирают различные варианты заполнения серой области первого раздела.

Если код лишён описаний того как он сделан, то агент, как и видящий его впервые программист, видит конкретную реализацию, но не видит условий почему он так сделан.

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

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

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

Предоставление контекста

Рассмотрим способы работы с предоставлением контекста

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

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

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

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

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

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

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

1 Предоставление проектных знаний

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

Например, если мы говорим агенту «исправь функцию X», и при этом в проекте имеется коренной md-файл с описанием общих правил работы с кодом. Если организационный процесс построен так что агент может приступить к работе не зная содержимого md-файла, значит это требование нарушено.

2 Достаточность контекста

Предоставлены ли все данные для того, чтобы выполнить задачу? может ли агент выполнить задачу без догадок о существенных свойствах системы?

Допустим, агент должен добавить новый API endpoint. Задача поставлена так, что он знает, какие данные нужно возвращать, но не знает, где должна выполняться авторизация. У него есть несколько вариантов: запросить уточнение, воспроизвести ближайший пример или применить известную ему архитектурную практику. Если правило проекта формализовано и доступно, неопределённость исчезает без дополнительного общения с человеком. Если же правила нет, то поведение агента может быть произвольным. В некоторых случаях это корректно (если в контексте задачи не важно как будет выполнена авторизация, агент может выбрать любое поведение серой зоны первого раздела). В других это может привести к снижению скорости или к ошибкам.

3 Прослеживаемость

Можно ли восстановить условия возникновения требований?

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

4 Разрешение конфликтов

Есть ли определённый порядок действий при неоднозначности и противоречиях?

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

Рассмотрим пример для 3 и 4. Допустим, что в проекте существует правило, что все операции записи должны выполняться внутри транзакции. Но позднее появилось требование выполнять некоторые операции асинхронно. Агент видит конфликт. Если ему доступны только две инструкции, он не обязательно сможет выбрать правильную. Если же известны основания решений, можно выяснить, что первое правило вводилось ради атомарности конкретных бизнес-операций, а второе связано с необходимостью вынести длительные процессы из HTTP-запроса. Тогда появляется возможность не просто выбрать более новую инструкцию, а найти решение, сохраняющее существенные свойства обеих.

5 Структурная целостность

Происходит ли время от времени реструктуризация локальных решений на более высоком уровне абстракции?

Таким образом, подобный подход показывает как можно увеличить допустимую скорость разработки, не теряя контроля. Это происходит не потому что человек быстрее проводит review (мастерство пилота), и не за счёт усовершенствования модели (мощности двигателя). Это происходит за счёт изменения самого процесса разработки: существенные ограничения становятся явными, информация подаётся в нужном контексте, типовые противоречия разрешаются по установленным правилам, а вмешательство человека требуется прежде всего там, где действительно необходимо новое решение.

Проектируем производственный процесс

1 Предоставление проектных знаний

Предположим, что у нас проект организован таким образом, что в корне проекта имеется файл ai.md включающий следующее содержимое:

Перед любыми действиями с файлами в подпапке:1. определить целевой путь задачи2. прочитать все `ai.md` от корня проекта до ближайшего к целевому пути3. применять прочитанные правила

(ai.md выбран как условное имя файла, выбранное без привязки к конкретной модели или провайдеру)

Далее, если у нас возникают требования на соответствующем уровне, мы их на нем и внедряем. Например, в такой структуре:

src/ controllers/ services/ repositories/ ai.md

Здесь в ai.md мы можем записать вышеупомянутые требования к 3LA. Как видим, если агент применяет дословно описанные правила коренного ai.md, то при любой работе на уровне src и глубже он обязан прочитать требования 3LA. Если же он работает вне src, то этот ai.md в контексте не участвует и это снижает объём контекста для работающих агентов.

Выполняется ли сейчас 1-е требование? Пока что нет, так как нам нужен механизм, обязывающий читать коренной ai.md. Этот механизм может быть как программным (конфигурационным), так и организационным (обязанность каждого разработчика начинать работу с сообщения «прочитай коренной ai.md»). Варианты могут быть разными, мы указываем на необходимость обеспечить данное свойство.

2 Достаточность контекста

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

Прежде всего, оно зависит от условия задачи. Здесь мы можем потребовать, чтобы при формулировке было определено условие проверки (AC, acceptance criteria), проверив которое мы убеждаемся, что задача выполнена. Такой подход дает агенту критерий для понимания выполнена задача или нет, и на нем он же может проводить тестирование. Это не дает абсолютного контроля так как не все тестируемо для всех возможных входных данных, а у обобщающих методов свои ограничения. Также тут нельзя сказать что организационно мы должны требовать от человека формулировки AC, но это может выглядеть так, что перед началом работы требуется определить AC и/или проверить текущее состояние, что также может быть задано агенту чтобы он в начале работы над задачей проводил соответствующие проверки.

Например, постановка задачи может звучать так: «реализовать функцию divide(a, b), возвращающую результат деления»:

double divide(double a, double b);

Затем добавляем критерий приёмки:

Функция возвращает результат деления a на b.

Теперь можно использовать несколько тестовых случаев, чтобы проверить реализацию на соответствие этому критерию:

divide(10, 2) == 5divide(0, 5) == 0divide(-10, 2) == -5

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

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

Например, нам необходимо описать предусловия и постусловия некоторой функции. Удобным вариантом может оказаться использование известных инструментов документирования (doxygen, javadoc, …) , когда в комментариях перед функцией или в подобном ее контексте описываются данные требования. В нашем примере это станет выглядеть так:

/** * @pre std::isfinite(a) && std::isfinite(b). * @pre b != 0. * @pre std::isfinite(a / b). * @post Returns a / b. */double divide(double a, double b);

Аналогично как другой пример, если мы хотим задать инвариант для объектов какого-то класса, то мы можем описать его в файле этого класса непосредственно перед ним или внутри него в виде комментария. Данное удобство базируется на предпосыке, что при чтении будет прочитан весь файл (как человеком, так и машиной), и условия будет сложно пропустить. Однако следует иметь в виду, что например если агент решит выполнить grep по ключевым словам или каким-то другим способом комментарии пропустятся, то эта предпосылка может перестать работать.

В случае применения более сложных моделей или общих требований может быть удобным их вынос в отдельное место и создание ссылок на них для тех или иных контекстов. Это касается протоколов передачи данных, правил работы с клиентами, общих архитектурных подходов для различных случаев, стратегии обеспечения безопасности и надёжности и др. Например, мы можем в одном месте описать как в проекте идет работа с исключениями, оформить ссылку в базовом или контекстном ai.md, и сказать что при любых преобразованиях, касающихся исключительных ситуаций необходимо подгружать и применять эти требования.

В нашем примере функции деления мы описываем в отдельном файле docs/error-handling.md:

# Error HandlingПри нарушении предусловий публичных функций:- выбрасывать std::invalid_argument;- сообщать, какое условие нарушено;- не возвращать специальные значения вместо ошибки.

и в ai.md:

При разработке или изменении публичных функций применять правила из docs/error-handling.md.

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

3 Прослеживаемость

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

Изначально причинами тех или иных решений может быть что угодно, но очевидно, что они находятся далеко от кода. Они могут быть озвучены при общении с заказчиком, зафиксированы в переписке, в системах управления проектом или issue-tracking и т.д. И наша задача сделать так, чтобы цепочка разворачивалась до них. Это важно для того, чтобы понимать причинно-следственные связи в проекте. Не только для понимания взаимосвязей, но и потому, что обстоятельства со временем могут измениться. С точки зрения проектирования организационного процесса нужно сделать так, чтобы агент имел возможность ее выстроить.

Например, мы можем создать общий журнал учета всех решений (decisions.md). Это необязательно один файл, можно отдельно хранить список фактов, различные другие источники данных и др. Но здесь нужно обеспечить сохранение и контроль. Это может быть описано в виде:

- [decisions.md](decisions.md) — история принятия решений в прямом порядке времени; отвечает на вопрос «Почему так, а не иначе?».decisions.md хранит историю решений в прямом порядке принятия: новый раздел дописываетсяв конец, прежние записи не редактируются и не удаляются. Новая запись содержит сквознойномер, проверяемое решение, основание и дату. Пересмотр оформляется новой записью со ссылкой на прежний номер. Прежние записи не удалять, не переписывать и не дополнять заднимчислом отметками об отмене.

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

4 Разрешение конфликтов

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

Прежде всего, если мы возьмем вышеописанный пример корневого ai.md, то в нем допускаются противоречия например если низкоуровневые утверждения противоречат тому что продекларировано на более верхнем уровне. Чтобы снять большинство из них можно добавить, что более высокоуровневые утверждения более приоритетны, нежели низкоуровневые. Также можно добавить процедуру проверки вносимых решений ai.md, которые должны быть согласованы с более высокоуровневыми. Так существенная часть конфликтов может быть решена. Но это достаточно простой вариант, и не факт что в таком виде он правильный. По-хорошему, лучше описать процедуру разрешения, например она может выглядеть таким образом:

При обнаружении противоречия или существенной неоднозначности:1. Определить конфликтующие требования и области их применения.2. Проверить действующие правила, ограничения и код затронутых компонентов.3. При необходимости восстановить основания решений через `decisions.md`, задачи и историю изменений.5. Попытаться найти решение, совместимое со всеми применимыми ограничениями.6. Если такое решение невозможно или требуется изменить действующее требование, запросить решение у пользователя.8. Не заменять действующие правила собственными предположениями.

Рассмотрим данный алгоритм для примера из четвёртой части статьи.

В проекте есть правило: запись бизнес-операций производится внутри транзакции. Поступает новое требование: перенести длительную операцию в асинхронную обработку. Выглядит как противоречие: как сохранить транзакционность, если операция теперь должна выполняться асинхронно? Но если агент смотрит в историю решений, то он может понять, что транзакция необходима для атомарного изменения нескольких связанных записей. А асинхронность требуется, чтобы не держать открытым HTTP-запрос во время длительной обработки. И не факт что они обязательно противоречат друг другу. Можно найти вариант, когда HTTP-запрос инициирует асинхронную обработку, а согласованное изменение данных выполняется в транзакции внутри обработчика. Как следствие, конфликт разрешён без дополнительного обращения к человеку. Это решение может быть записано как новое. При этом агент не отменил старое правило и не придумал новое бизнес-требование, а нашёл способ удовлетворить оба.

А что если конфликт неразрешим? Допустим, поставлена задача отмены уже отправленного заказа, но действующее предметное правило запрещает это. Агент исследует decisions.md и понимает, что запрет напрямую прописан в договоре с партнёром. Здесь нельзя применить новое требование, и нельзя самостоятельно отменить существующее ограничение. Процедура должна привести к внешнему запросу с конкретной информацией: «Требуется отменить отправленный заказ, но действующее правило DEC-014 запрещает это на основании договора с партнёром. Изменились ли условия, позволяющие пересмотреть запрет?» Такой запрос существенно отличается от общего «здесь что-то непонятно».

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

5 Структурная целостность

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

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

Заключение

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

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

Исторически преодолеть звуковой барьер удалось не только благодаря более мощным двигателям или мастерству пилотов. Потребовалось изменить подходы к проектированию самолётов. Аналогичная задача сегодня стоит перед нами: не замедлять разработку до привычной скорости, а научиться организовывать процессы так, чтобы выдерживать новые скорости.

Источник: habr.com

0 0 голоса
Рейтинг новости
1
0
Подписаться
Уведомить о
0 комментариев