Выпуск #31 · 5 ноября 2026 г. · 1:52:07
Средовой подход к ИИ-разработке | Руслан Сафин, CTO Бындюсофт
Описание
ИИ-агент за ночь добавил в интернет-магазин новую платёжную систему, и все тесты проходят. Что нужно знать об этих тестах, прежде чем нажать кнопку деплоя? И кто отвечает за ошибку, если её первым заметит покупатель?
В выпуске
— Откуда взялся средовой подход и чем он отличается от системы из «чёрных ящиков».
— Что настроить в интернет-магазине до первого деплоя агента и кто может менять правила.
— Как задать права доступа и описать бизнес-требования и сценарии проверки.
— Когда результату можно доверять и сколько стоят проверки.
— Можно ли использовать одну среду для интернет-магазина, Telegram-бота и CRM.
— Кто такой средовой инженер и как измерить окупаемость подхода.
— Кто отвечает за баг в продакшне и как проверить гипотезу подхода.
Тайм-коды
00:00 — Руслан Сафин и главный вопрос: где ускорение от ИИ?
00:47 — Откуда взялся средовой подход
08:57 — Чем среда отличается от системы из «чёрных ящиков»
13:31 — Почему бы просто не переписать всё за ночь?
22:14 — Интернет-магазин: что настроить перед первым деплоем агента
24:59 — Кто может менять правила и проверки
31:37 — Права доступа заданы. Что ещё нужно описать?
44:10 — Где проверять бизнес-сценарии
55:03 — Когда результату можно доверять и сколько стоят проверки
01:01:56 — Можно ли построить одну среду для любого проекта
01:09:58 — Кто такой средовой инженер и какой опыт ему нужен
01:13:26 — Законы, стимулы и отбор на примере магазина
01:18:54 — Ниша для новой платёжной системы: что положить в контракт
01:22:44 — Если всё сводится к тестам и линтерам, зачем разные термины?
01:29:33 — Что делать с готовым кодом, когда меняются правила
01:32:23 — Как узнать, что ограничения среды мешают агенту
01:34:46 — Окупается ли подход на проектах Руслана
01:38:10 — Баг дошёл до продакшна. Кто отвечает?
01:40:10 — Какой результат опроверг бы гипотезу Руслана
01:43:05 — Чему учить начинающих инженеров, когда код пишут агенты
01:48:57 — Как присоединиться к экспериментам со средовым подходом
Материалы и ссылки
• Telegram-канал «Архитектура распределённых систем» — https://t.me/rsa_enc
• Статья Руслана Сафина о средовом подходе — https://habr.com/ru/articles/1100302/
Связанные выпуски
• ИИ в разработке: код дешевеет, проверка дорожает | Сергей Сергеев, Manychat
Транскрипт
Что такое средовой подход
Владимир Гриненко. Всем привет, теле- и радиозрители подкаста «Гриненко про». Сегодня в гостях Руслан Сафин, технический директор и партнёр Byndyusoft. Будем говорить на такие фундаментальные, основополагающие темы про то, как вообще в эпоху ИИ должна измениться разработка, чтобы мы наконец-то начали поспевать за роботами. Будем разбираться с методологией, которую Руслан предлагает попробовать в качестве решения вот той самой проблемы, что роботы вроде бы должны были нас ускорить, а на самом деле ускорение по приборам не очень-то заметно.
Руслан, привет!
Руслан Сафин. Всем привет.
Владимир Гриненко. Спасибо тебе большое, что пришёл. Я успел послушать твой рассказ на «АрхФесте». Мне показалось, история интересная и вместе с тем до боли знакомая. Очень многие идеи существовали и до ИИ, и всё, что сейчас происходит, оно достаточно созвучно с тем, что ты предлагаешь, и оно как будто бы таким естественным образом случается.
Расскажи для тех, кто не в курсе, что это за методология. А дальше уже будем разбираться в подробностях.
Руслан Сафин. На самом деле, мне многие говорят, что всё, о чём я рассказываю, в том или ином виде уже есть, оно всегда было. Я такой: «Блин, опять я капитанствую, рассказываю очевидные вещи». А потом все говорят: «Блин, очень круто!» Те же люди, которые говорят, что всё это было. Видимо, мне удаётся это скомпоновать. Да, я рассказывал про средовой подход.
У меня именно в этом и цель. Мы все это используем, в каком-то виде все это встречали в различных уже имеющихся подходах, но на мой взгляд, мы как-то не определяем, не объединяем это всё в единую методологию, в единый подход. Это уже назрело. Мы десятилетиями использовали всякие подходы программирования и разработки человеком, командами, различные паттерны, принципы, там, будь то ООП, будь то какие-то более крупные подходы, такие как системный подход к разработке софта.
А вот сейчас мы стоим именно на каком-то кардинальном сдвиге. То, что мы раньше делали сами, и я люблю так говорить, белковым мозгом, сейчас перекладывается на агентов, и, на мой взгляд, вот те разные человеческие подходы, то, к чему мы привыкли, оно сдвигается и коренным образом заменяется. Это такая расширенная вводная. Я рассказывал про средовой подход. Есть у нас системный подход, к которому мы все привыкли, как разработчики, даже в целом, как инженеры.
А системный подход развивается уже много десятилетий, не только в сфере IT. Есть много работ, есть много различных, даже теорем. Как это всё устроено. И на самом деле, для меня для самого несколько лет назад было открытием, что системным подходом всё не ограничивается. Помимо системного подхода есть ещё совершенно различные стороны, с которых можно подходить вообще к человеческой деятельности.
Это есть эволюционный подход, это средовой подход, потом есть даже сферный подход и так далее. Это вот всё каким-то образом уже было проработано в разных научных исследованиях, даже не применительно к нашей сфере, к IT, даже не применительно только к инженерии. Это работы и по социологии, и по психологии, и по архитектуре, но не IT-архитектуре, а архитектуре зданий, архитектуре городов.
Есть различные подходы, и мне было интересно попробовать в них разобраться. А потом понять, что из них можно использовать в IT. А потом оказалось, что ещё и агенты, они примерно то и делают, что всякие умные люди ещё 50 лет назад описали в средовом подходе. Так, давайте, наверное, слишком много вокруг да около я хожу. Давайте начнём с главного. Вот есть системный подход, в центре стоит система.
Система — это что такое? Когда мы знаем каждый компонент, каждый винтик, каждый, условно, класс нашего программного обеспечения, и знаем все взаимосвязи. И таким образом мы определяем, как работает целое, как работает вся система. Мы должны знать досконально, из чего она состоит, как все эти компоненты друг с другом взаимодействуют. И исходя из этого, мы понимаем, разбираемся и прогнозируем, как будет работать целое.
А среда, в отличие от системы, в среде количество компонентов, оно может быть очень большим, может быть даже бесконечным. И нам нужно работать каким-то образом со средой, когда мы не знаем каждое, во-первых, количество компонентов, и не можем посчитать и как-то себе в голове уместить количество, тем более взаимодействий между разными компонентами. Давайте представим машину.
Машину можно рассмотреть автомобиль как точки зрения системы, мы знаем там, как работает двигатель, мы знаем, как работает не знаю, штука, которая топливо подаёт, как потом передаётся импульс на колёса. Но когда мы рассчитываем, за сколько времени из пункта А автомобиль приедет в пункт Б, нам всё это знать необязательно. Мы уже на более высоком абстрактном уровне делим расстояние на скорость, да?
Мы не учитываем, как внутри вот бензин перерабатывается в энергию, передаётся на колёса. Нам это неважно. Так вот, когда мы вот на таком более абстрактном верхнем уровне рассматриваем машину, мы используем средовой подход. Мы не погружаемся в детали, мы знаем некие внешние законы, внешние формулы и рассчитываем поведение чего-то. Другой пример, наверное, более близко описывающий среду — это вот ровная гладь воды.
Мы кидаем туда камень, расходятся концентрические волны. У нас есть всё, чтобы мы могли описать, с какой-какой высоты будет волна. Как, сколько раз они туда-сюда разойдутся. У нас есть формулы, мы всё это обсчитываем, мы можем это, эти все процессы описать. Но при этом мы не учитываем взаимодействие каждого компонента внутри воды. Что такое компонент? Это молекула. Их там бесконечно практически много, и они как-то между собой взаимодействуют.
Естественно, мы, если бы мы пытались это смоделировать, посчитать, нам бы никаких мощностей не хватило. Но у нас есть формулы расчёта волновых процессов, и всё работает. Так вот, если подытоживать, когда мы подходим в средовом подходе, мы уже не знаем, что там внутри чего-то, но мы знаем, как оно работает, что оно делает, и можем как-то этим на это влиять и управлять. Условно, если применять к IT, вот мы не знаем, что там внутри 10 микросервисов, 100 микросервисов, либо там монолит, там объектно-ориентированное программирование, Python или Go, либо какой-то ещё язык программирования из новых.
Нам это не так важно. Нам важно, что внешнее программное обеспечение работает так, как нам необходимо. Это вот, наверное, совсем верхнеуровнево. И моя идея в том, чтобы, исходя из средового подхода, создать некийта- некую такую мастерскую, внутри которой агенты и агенты будут создавать софт на выходе, который полностью удовлетворяет нашим требованиям. Мне кажется, немножко сумбурно.
Но да. Есть различные материалы, статьи, там более структурированно я это всё объясняю.
Чёрный ящик и теплица
Владимир Гриненко. Давай я попробую уточняюще по ходу задавать вопросы, и мы как раз разберёмся. Примеры, которые ты приводишь, если пытаться их переложить на разработку софта, мне кажется, не до конца раскрывают идею, потому что само по себе задача спрятать сложность за каким-то блэкбоксом, она же вот с каждым уровнем абстракции и при системном подходе сохраняется. У тебя там изначально есть какая-то функция, которая оборачивает поведение, над ней там у тебя есть какой-то, допустим, объект, сервис.
Над сервисом, там действительно какой-то оркестратор и так далее. И ты каждый раз, оставаясь в системном подходе, можешь прятать эти особенности реализации, эту сложность за каким-то API. И вот в чём разница между тем, что ты в системном подходе используешь такие блэкбоксы и средовым подходом, про который ты говоришь?
Руслан Сафин. Да, всё так, ты всё правильно говоришь. Я, наверное, недостаточно там чётко сформулировал. Средовой подход я предлагаю применять к процессу создания программного обеспечения. Само программное обеспечение, которое получается на выходе, оно прямо вообще классическое. Оно строго детерминированное, оно может быть построено по системному подходу. Разница в том, что оно строится не нами, не инженерами, а их агентами.
Условно, смотри. Я себя представляю как некоего архитектора-садовника. Я создаю некую теплицу, и в теплице уже управляю различными условиями. Я выстраиваю температуру нужную, выстраиваю свет, выстраиваю влажность и так далее. А уже растения, они благодаря этим условиям растут, произрастают сами. В нашем случае растение — это конкретное программное обеспечение. Каким-то образом, понятно, каким, сейчас это и агенты, оно создаётся, и оно нам растёт в нужную сторону и получается какой-то нужной формоый, там, с нужными функциями и так далее.
Я, как садовник не беру и, не знаю, там каждый листочек на скотч или на скрепку не прикрепляю. Я создаю условия, чтобы растение там не жухло, не умирало, а оно росло, как нужно. Так вот, средовой подход — это про то, чтобы создать некие условия. Агентом. В определении средового подхода прямо это и выделено, что в отличие от системного подхода, мы управляем именно условиями. Мы взаимодействуем опосредованно или мягко.
На что-то, на что-либо, на то, что внутри нашей среды. Мы не говорим агенту: напиши такой-то класс, напиши такой-то тест, здесь исправь ифчик, здесь поставь цикл и так далее. Это было бы. Агентская разработка. Это системный подход с помощью её агентов. А мы говорим, задаём некие, можем дальше про это поговорить, некие законы, некие стимулы, некие условия, для того, чтобы агент сам правильно писал софт, как нам нужно.
Смотрите, на самом деле, ведь человеческая разработка — это всё то же самое. У нас есть некие требования, есть команда разработки. Мы отдаём в команду разработки эти требования, а там внутри вообще недетерминированный процесс. Что там происходит, какую они архитектуру выберут, там, я не знаю, каким образом напишут. Вообще, на самом деле, всё то же самое. Главное, чтобы в конце прошли некие функциональные тесты, там заказчик всё принял, либо тестировщики всё проверили и сказали, что всё ок.
По сути по процессам особо ничего не меняется. Вот то, что раньше мы использовали как хорошие практики для управления командой, для технического управления командой в том числе, хорошие практики, архитектурные и так далее. Теперь всё то же самое нам нужно переложить на агентов. Но теперь главная разница в том, что, на мой взгляд, все эти условия стали намного более критичными.
Потому что команда людей, она пишет софт дорого. Каждая строчка кода, каждый час разработки достаточно дорог. А агенты могут это генерировать с огромной скоростью строчки кода, ещё и работать могут практически 24/7. Понятно, что токены тоже платные, не бесконечные, но всё же. Мы теперь вступаем в ту эру, когда написание именно строчек кода, оно на несколько порядков стало дешевле и быстрее.
И поэтому вот те условия, те какие-то, не знаю, функциональные требования, нефункциональные требования, которые мы раньше закидывали в команду, вот их важность их правильности, скажем так, она возросла многократно. Ты раньше отправил Васе не до конца сформулированные требования. Ничего страшного, Вася умный, он сам пришёл у тебя, до уточнил, там уточнил, какую архитектуру использовать и написал всё верно.
Теперь, если мы ошиблись на уровне какого-то задания, базового правила, у нас агенты буквально за ночь, они там очень много нафигачат, уйдут не в ту сторону, и цена ошибки будет высокой. Особенно если они могут каким-то образом там в прод всё выкладывать.
Владимир Гриненко. А почему не наоборот? Вот раньше, если ты на берегу сформулировал неверно направление, то этот самый дорогостоящий Вася будет очень долго и медленно идти не в ту сторону, и ты узнаешь о том, что он пришёл не туда спустя месяц разработки, и заплатишь ему овердофига. Агенты, если пошли не туда, ты к утру узнаешь, что получилась ерунда, выкинул всё это, и к следующему утру у тебя уже всё прекрасное заново.
Почему не наоборот? Почему не смотреть на это? Ошиблись и ошиблись,— Бог с ним.
Руслан Сафин. С одной стороны, тут, наверное, надо разделить именно масштаб ошибки. Первое. Во-первых, наверное, если Вася ушёл в разработку на полгода и -, как сказать, потом вернулся совсем не с тем. Наверное, зря мы ему платим много денег. Человек, особенно грамотный, профессиональный инженер, он этим и отличается, что он как можно раньше там задаст вопрос. Про агентов, если мы можем, условно, к утру, они ночь поработали, утром вернулись, тебе показали, спросили, то, наверное, цена ошибки не так высока.
Я, наверное, больше имел в виду если мы что-то заложили в среду как закон либо как стимул, наверное, дальше про это поговорим, что это такое. И мы про это узнали только через какое-то длительное время. Агенты уже написали кучу софта, и в этом софте есть какой-то корневой баг, но малозаметный, который мы не заметили ни метриками, ни тестами, никакой-то ручной проверкой. Кстати, вот ручная проверка, она достаточно спорная.
Если мы генерируем за ночь огромное количество функционала, а потом вручную это всё проверяем, то, скорее всего, у нас создание софта не ускорится. Да? Мы должны как-то, ну весь цикл создания софта пересмотреть. А если мы ускорили вообще всё, в том числе и тестирование, и мы с утра только нажимаем там кнопку «Approve» и залить в прод, тогда вот как раз эта ошибка, которая в самом базовом законе условий среды.
Заложена, не та температура полива растений. Она выстрелит, может выстрелить больно, достаточно поздно и на уже большом масштабе. Мне кажется, надо поговорить именно про больше про конкретику, потому что я сейчас пользуюсь всякими примитивами среды, законы, стимулы.
Владимир Гриненко. Я хочу, наверное, вот какой до того, как уходить уже к конкретным терминам вопрос ещё задать. Ты говоришь, что здесь есть прямая аналогия с тем, что было раньше, и я при этом слышу, что ты скорее вот говоришь про аналогию вида. У нас раньше были линтеры, у нас раньше были какие-то автотесты и какой-то CI/CD, чтобы задавать эту среду для разработки. Но мне интересно вот что. На самом деле все эти запчасти, их изнутри уже создавала команда разработки, и агенты тоже могут сами для себя что-то такое генерировать.
И в этом смысле это может быть уже не внешней средой, которую ты как садовник готовишь, а потом оно начинает там как-то колоситься внутри, а частью вот того биогеоценоза, который сам себе себя как-то поддерживает. А средой для Ч человеческого написания софта, мне кажется, скорее является кофе-поинт с печеньками, курилка и какие-нибудьм маркерные стены вокруг. И вот если такую аналогию брать, насколько это применимо здесь?
Руслан Сафин. Давай, наверное, про человеческую среду. Ты прав, всё это давно уже есть, но, мне кажется, больше тут подходит, допустим, какая-то платформа разработки. Да, которые предоставляет тебе. Ты там можешь как-то себе базу данных накликать, какие-то микросервисы накликать, там ты можешь обращаться к другим системам, но эти обращения будут квотированы. И если ты создаёшь базу данных, тоже у тебя какой-то определённый будет лимит на её использование и так далее.
Все эти вот платформы в крупных IT-компаниях, они предоставляют возможности для команды разработки, но в то же время они как каким-то образом ограничивают. Они настраивают поля практики без политики безопасности и так далее. Вот, кстати, ИБ тоже, оно очень сильно ограничивает, и оно является такими какими-то, там границами, законами для любой разработке, будь то агентская разработка, будь то разработка вручную людьми.
Тут скорее такие примеры. А по поводу средовой разработки и написания тестов, ты абсолютно прав. Если один и тот же агент пишет и тест, который себя проверяет, и код, который потом проверяет этот тест, то это, конечно, хорошо, лучше, чем совсем без тестов, но это не может быть, не может считаться окончательной приёмкой. Даже если у тебя два разных агента, один пишет код, другой пишет тест, то они очень легко и просто могут ошибиться одинаково.
Условно, у тебя какая-то нечёткая формулировка в требованиях, они это одинаково неверно интерпретировали,ну и, соответственно, тест у тебя проверяет не то. Когда мы говорим про создание среды, эти вот опять же, тесты и законы, и проверки, они должны быть вообще вне зоны доступа агентов. Потому что агенты умные. Все мы читаем новости, вон у Anthropic, у OpenAI, они там сбегают из-под контроля, сами под себя все политики доступа перенастраивают и потом творят всякую дичь.
Так вот, тут надо очень жёстко разделить, и нам, как этим садовникам, средовым инженерам понимать, какие проверки, как написаны, и на основе этого уже принимать решение. Да, этих проверок достаточно, либо их недостаточно, нужно там что-то вручную написать, нужно вручную проверить проверки и так далее. У нас есть среда, внутри которой агенты пишут некий софт. И есть внешние некие, законы, там, тесты, проверки, как угодно можно их назвать, которые этот результат генерации софта очень быстро проверяют и отсекают.
Это я называю отбором внутри среды. Полная аналогия с естественным отбором. И чем быстрее мы скажем, что этот вариант генерации недееспособен, тем лучше. Агент сразу пойдёт: «Ага, я не знаю, поменяю архитектуру, изменю подход, ещё немножко подумаю и попробую по-другому». В чём тут суть? Агенты, они очень быстро могут генерировать совершенно разные варианты, в том числе архитектуры, подходов к реализации и так далее.
И среда должна, во-первых, быстро говорить и отсекать нежизнеспособные, то, что не проходят какие-то проверки по безопасности, там, по доступам и так далее. И, во-вторых, правильно направлять. Даже если два варианта, допустим, у вас прошли отбор, среда должна сказать: «Вот смотри, здесь вот метрики, допустим, архитектурного проектирования лучше, вото здесь вот необязательных проверок пройдено больше».
Давай вот выберем второй вариант. Ты двигайся туда. Условно, некий стимул подсказывать агентам, в каком из вариантов нам лучше двигаться. Примерно как градиентный спуск в классическом ML. Когда мы пробуем вообще во все стороны идти, а потом понимаем, что ага, вот в эту сторону лучше и так далее. И постепенно так шажками мы продвигаемся вперёд. Примерно такая разница.
Законы среды на примере интернет-магазина
Владимир Гриненко. Можешь ли раскрывать термины не абстрактно, а выбрать какой-то конкретный кейс? Вот, допустим, мы хотим спроектировать некоторую действительно систему, какой-то кусок софта. И вот если бы мы его создавали в средовом подходе то что бы мы делали? И вот, соответственно, если мы говорим про какие-то законы, что бы конкретно это было на примере этой разработки, что бы там было нишей и так далее, вот по всем терминам.
Руслан Сафин. Угу. А у тебя есть какой-нибудь пример? Вот было бы интересно, мы заранее с тобой никакой пример не готовили, и вот на да, чужом примере я бы попробовал рассказать.
Владимир Гриненко. Давай возьмём какой-нибудь супер-типичный интернет-магазин. Он, с одной стороны, достаточно всем понятный, с другой стороны, очевидно, что там есть опасные части, про которые важно позаботиться. И вот если мы хотим доверить агентам катить изменения в прод, вот что мы должны? Как настроить среду?
Руслан Сафин. Да, интернет-магазин — простой для меня пример, потому что я все лекции свои на этом примере веду, не по средовому даже подходу. Да, сейчас попробуем. А Единственное, я бы такую оговорку сделал. Если там кто-то из слушателей захочет попробовать средовой подход, необязательно прямо новый софт писать на нём сразу. Можно уже имеющийся софт, какую-то там часть, выделить и дописать какую-то функциональность, делать задачу либо какой-то конкретный модуль.
В. Возвращаясь к интернет-магазинам, я выделяю, несколько примитивов, что мы должны в среде запроектировать, как вообще подойти к созданию такой среды. Первое, что мы должны сделать,— это выдать создать какие-то нерушимые законы. Как я люблю говорить, в IT, к сожалению, нет неких физических законов, которые бы нас ограничивали. В реальной инженерии есть физика, есть биология, есть какие-то, там силы притяжения, которые ты никак не нарушишь, и тебе приходится в твоих подходах, паттернах это всё учитывать.
В программировании ничего такого, нет, и мы можем любого макаронного монстра создать, он будет компилироваться, он будет запускаться, и как-то там работать. Нету каких-то физических законов, которые там сразу его обрушат. Так вот, моя мысль в том, что наша задача, архитекторов прежде всего, создать такие законы. Они будут полезны и для человеческой разработки, но вот для агентской, для средовой разработки, они прямо критически важны.
Что-то вообще нерушимое, что нельзя нарушить. Если у нас микросервисная архитектура и мы приняли подход, что у нас одна база на один микросервис в том же интернет-магазине, то у нас прямо никакого даже физического доступа, сетевого доступа не должно быть у микросервиса до чужой базы. Условно, на уровне там инфраструктуры мы настраиваем, что у микросервиса есть доступ, по, допустим, порту 1433 или какой там стандартный для MS SQL, только к одной к своей базе.
И никакой другой он сходить не может. Даже если агент напишет, каким-то образом в connection string подставит, то у него при запуске всё упадёт, потому что нет сетевого доступа.
Владимир Гриненко. Пока ты дальше не ушёл, вот вопрос: эти вещи, которые ты сейчас говоришь, их должен настраивать в этом случае человек, чтобы у агента не было возможности это поменять? Или всё-таки эту часть мы тоже делегируем агентам, но каким-то отдельным, не тем, которые потом в дальнейшем будут писать код приложения?
Руслан Сафин. На мой взгляд, сейчас вообще вся человеческая деятельность, она построена с использованием ИИ, агентов, там, не агентов, чатов, неважно. Естественно, когда мы создаём среду, мы точно так же можем ими пользоваться. Условно, мы создали эти вот правила, не знаю, прописали сетевые правила, ещё где-то. Мы можем даже теми же самыми агентами это сделать. Просто мы уже создали среду, она работает, и потом мы запускаем агентов внутри неё.
Главное, чтобы когда мы запустили внутри, у агента уже не было доступа к изменениям тех правил. Не так важно, он их написал либо нет. Главное, что вот в последующей его работе он не может до них дотянуться, вспомни. Наверняка он про них знает, но у него просто нету доступа их перезаписать.
Владимир Гриненко. Получается, что нам это ограничение, чтобы обеспечить, нужны какие-то заборы, которые будут включаться вот после того, как агент уже всё настроил, а потом мы у него возможность это настраивать, должны как-то отобрать, при этом ведь мы понимаем, что никакая среда никогда не будет отлита в граните навсегда. И она тоже будет эволюционировать. И, соответственно, если мы принимаем, что агент участвует в её настройке, то вот как мы будем то давать, то отбирать у него возможность её шатать?
Руслан Сафин. И да, даже если это делает один и тот же средовой инженер, не DevOps где-то отдельно настраивает в своём контуре, не ИБ-специалист, который тоже как-то смотрит про доступы. Как я себе это вижу? Ка, как, допустим, мы делаем? Условно, ты с помощью агента в отдельном репозитории правишь сетевые настройки Кубера, какие-то ямлики и так далее, прописываешь эти правила. Вот, совершенно отдельный репозиторий.
Да, и потом этот репозиторий просто запускается, у тебя инфраструктура из него разворачивается, и уже внутри этой инфраструктуры работают микросервисы. Агент я не знаю, это можно как угодно организовать. Когда мы запускаем работу агента, мы же всё равно настраиваем доступы к конкретным репозиториям. Условно, под этой учёткой у тебя доступ сюда есть в репозитории, допустим, кода интернет-магазина, а доступа к репозитории инфраструктуры у тебя нет.
Наверное, самый простой вариант — это запускать агентов из-под разных учёток, у которых есть там права, разные права на запись или чтение в разные репозитории.
Владимир Гриненко. Что тогда гарантирует, что вот тот агент, у которого учётка предполагает возможность менять настройки, не поменяет их вне контроля человека. Вот мы же договариваемся о том, что всё это нам нужно, чтобы мочь катить в прод, не глядя, условно. И вот если у нас остаётся эта лазейка, то, не глядя, всё равно не получится. Тут речь о том, что мы можем просто фокусировать внимание только вот на эту область, а на остальные не смотреть.
Руслан Сафин. Если мы говорим про какой-то стартап, где вообще один человек отвечает за всё, то, наверное, ему надо как-то на локальном компьютере всё это каким-то образом настроить. Если мы говорим про какую-то более крупную команду либо компанию, с IT-отделом, обычно этим делают, это делают различные люди. Кто-то условно DevOps настраивает Kubernetes, настраивает там инфраструктуру и так далее.
У разработчиков вряд ли есть доступ. Если мы говорим про обычную разработку, чтобы они пошли и не знаю, в кубере себе какие-то права сетевые поменяли. Тут, на самом деле, всё то же самое. И DevOps, и разработчик могут использовать там тот же Claude либо тот же Codex, условно, одного агента, но они будут совершенно на разных этапах даже работать. Один работает над средой, другой работает над конкретным проектом.
Тут, мне кажется, вопрос немножко за рамками именно средового подхода. У тебя просто два разных проекта, и тебе нужно организовать между ними разный доступ.
Владимир Гриненко. Я просто к этому отношусь так, что через 5 минут в таком режиме ты начнёшь хотеть ещё сильнее отзумиться, подняться на следующий уровень абстракции и уже манипулировать этим с какого-то такого: "Так, вот теперь для меня средой становится какой-то такой слой, на котором и настройки Кубера, и всё, что в нём крутится — это уже тоже что-то внутри системы, которой манипулируют роботы, а я хочу повелевать терминами.
Увеличь мне конверсию на 10%.
Руслан Сафин. Я уже хочу на уровне сферного подхода. Средовой подход, там дальше ещё сферный есть, когда у тебя несколько сред внутри одной сферы. Там вообще другие подходы. Я с тобой согласен, что человек, особенно разработчик, существо ленивое. Как только что-то заработало, он захочет это переложить. Я бы как тут поступил? Я конкретно с такой проблемой ещё не столкнулся, но вот если таким образом организовать работу, нам точно нужен некий тест.
Условно, а, тест, который говорит, что вот ты агент, который внутри среды, иди попробуй и измени что-то в репозитории, в котором мы работаем над средой. И этот тест нужно постоянно запускать, и если у него получится да, значит, всё, у нас сломалось этот разделение, водораздел прав, и значит, надо, срочно это фиксить. Я бы такой тест прямо включил, не знаю, в CI/CD внутренние в среду, чтобы каждый раз прямо ему говорить: «Иди попробуй, измени».
Да. И проверять, что он там упал с отсутствием прав, либо у него получилось, значит, всё, значит, тест красный, мы стопим билд, стопим всю разработку и говорим там: «Всё, доверять результатам нельзя, потому что у внутренних агентов есть возможность влиять на внешние проверки, на эти внешние законы. Получается, что мы, как инженеры какого-то механизма, можем изменить законы физики, в котором этот механизм должен работать.
А это не должно быть так.
Владимир Гриненко. Давай тогда возвращаться к интернет-магазину. Вот, допустим, мы задали законы про разграничение прав доступа. Что происходит дальше?
Руслан Сафин. Да. Ещё я тут хотел дополнить, что мы необязательно именно, как мы сейчас много поговорили про там ограничения прав сетевого доступа. На самом деле, необязательно прямо так жёстко рубить. Мы же можем задать некий просто архитектурный тест. Вот у меня прямо есть там цикл статей на Хабре, много выступлений про то, как архитектуру проверять тестами. У нас есть архитектура эскот.
Да, мы проверяем, что она соответствует продакшн-состоянию, то, что на самом деле у нас в проде крутится. И потом мы просто по графу можем проверить, условно, что этот микросервис, он входит только в свою базу, ни в какие другие базы не ходят. Мы, второй вариант — это не обрубать на уровне там сетевого доступа. Мы теоретически можем в чужую базу сходить, но у нас есть тест, который это проверяет и который просто на этапе CI/CD заблокирует сборку. Тут важный момент, что всё то же самое, этот тест он должен быть недоступен для внутренних агентов. Это вот разграничение никуда не уходит. Нам нужно либо физически ограничить доступ, либо задать некий тест, который проверяет выполнение нашего правила. Во многих компаниях, во многих командах, я думаю, почти везде сейчас есть ADR, Architecture Decision Record.
И они есть просто в виде текстового файла, и команда их соблюдает. Якобы соблюдает. Так вот, я уже там, давно говорю, что все ADR должны быть покрыты тестами ещё до того, как агентская разработка прямо выстрелила там в этом году или в прошлом году. Всё это должно проверяться явно. А не так, что мы там сказали: «Дорогие разработчики, вот вам список ADR, пожалуйста, всех их соблюдайте».
Точно так же сейчас многие говорят и агентам: «Смотри, здесь у меня папка с архитектурными решениями, прочитай их все и соблюдай». Мне тут подсказали хороший пример. Вы пробовали когда-нибудь просить кота не ссать в угол? Можно даже «пожалуйста» добавить. Когда ты к коту обращаешься или когда ты там промпт пишешь или скилл пишешь: «Пожалуйста, выполняй ADR». Да, агенты будут пытаться это сделать, но никакой гарантии не будет, что архитектурная договорённость будет выполнена.
Поэтому вот нам и нужен прямо ну жёсткий тест, который отслеживает выполнение этого физического в кавычках, закона.
Владимир Гриненко. И этот тест пишется вне контура, который будет реализовывать саму бизнес-логику.
Руслан Сафин. Да. Моя идея в том, что мы создаём среду, и потом в этой среде мы уже можем решать класс задач. Сегодня нам нужен интернет-магазин, завтра нам нужно будет его добавить, как-то дописать, а послезавтра мы захотим не знаю, несколько инстансов разных интернет-магазинов для разных категорий товаров запустить. И вот среда, она, скорее всего, с минимальными изменениями подойдёт для, условно, нескольких разных систем, либо нескольких модулей, примерно одинаковых.
Не то чтобы одинаковых, а примерно из одной сферы. Условно, мы создаём среду, чтобы не решить какую-то конкретную одну задачу, а чтобы решить сразу класс задач, в том числе и на будущее, которых сейчас ещё нет. И в этом, мне кажется, вот в том числе экономическая эффективность вкладывания вот в такие среды. Если вам нужно написать какой-то MVP, там стартап и завтра, скорее всего, выкинуть, то вам подойдёт просто агентская разработка, вкладываться в среду, скорее всего, нет смысла.
А если вы понимаете, что вы если-а, там добавляете, не знаю, какие-то типовые интеграции, и на каждую интеграцию у вас уходит по 2—3 месяца, то, скорее всего, вам нужна среда, которая будет просто их как на конвейере фигачить.
MVP и цена итерации
Владимир Гриненко. Правильно ли я тогда слышу, что это в каком-то смысле лишает старый подход, когда мы итеративно какими-то, спринтами катим в продакшн маленькие итерации, потому что, вот, мы, допустим, хотим сделать какой-то MVP, проверить гипотезу. А потом мы хотим из него вырастить что-то прямо большое, серьёзное, и на каждом таком шаге мы будем в значительной степени влиять не только на бизнес-логику, но и на кучу таких фундаментальных архитектурных и инфраструктурных частей.
И, соответственно, если мы в старом бы мире жили и меняли бы все эти слои одновременно, и вот перенесли бы этот подход сейчас сюда, то получается, мы ничего особо не экономим, потому что нам придётся с каждой итерацией заново менять и среду тоже. А ты говоришь: «Давайте мы сначала инвестируем в создание хорошей среды, а внутри неё уже там сад вырастет сам». И получается, тебе нужно на берегу угадать вот конечную точку, куда ты хочешь прийти, даже для тех систем, которые действительно ещё пока не существуют.
Правильно ли такое восприятие?
Руслан Сафин. Смотри, на мой взгляд, подход с MVP, он почему развился? Почему все его используют? Потому что очень дорого сразу сделать какой-то готовый софт, сложный софт, который учитывает все варианты и так далее. Но если мы именно создание конечного софта, конечного результата делаем дешёвым. То получается, этот подход MVP, он должен относиться не к нашему конечному продукту, А к среде, которая его создаёт.
Мы можем среду точно так же развивать, проектировать, создавать вот по подходу MVP. Сначала какая-то небольшая, простая, потом более сложная и более сложная. А уже внутри среды создаётся продукт. И вот он, если у нас там сразу там с этапа MVP среды получилось плюс-минус хорошо, сам продукт на выходе уже может быть чуть ли не полноценным, начиная с первых итераций. Да? Он может быть таким каким-то простым по бизнес-параметрам бизнес сценарием, если мы немного туда заложили.
Но вот с точки зрения качества кода, потому что именно само написание кода дешёвое, он может быть, сразу уже более крутым, чем если бы мы писали его руками. Моя идея в том, что нам не нужно переносить. То, что мы, те практики, которые мы относили к человеческой деятельности, они остаются. Допустим, создание MVP. Получается, сейчас человеческая деятельность, она будет направлена в этом подходе на создание среды.
А создание самого продукта — это уже нечеловеческая деятельность, и там другая экономика работает и другие подходы. Ну здесь я очень люблю пример с шахматами. Есть нейросеть Альфа-Го, которая всех выиграла в ГО. Её обучили на там десятках, сотнях миллионах человеческих партий игре в шахматы, и она выиграла все другие шахматные движки. Про людей уже нету речи, там с 2000-го года человек проигрывает компьютеру.
Так вот, а когда появилась Альфа-Зеро, примерно та же самая нейросеть, только её вообще не обучали на человеческом опыте, человеческих партиях в шахматах. Она выиграла вот предыдущую версию просто с разгромным счётом. Потому что у неё не было человеческих стереотипов и вот переноса именно каких-то человеческого мышления в шахматах. Так вот, и на мой взгляд, во всей деятельности, в том числе и IT, примерно то же самое сейчас происходит.
Допустим, когда Google Translate разрешил перевод не с английского на итальянский, а с английского сначала на внутренний язык нейросети, а потом на итальянский. Любой язык, качество очень сильно скакнуло. Так и в программировании. Сейчас мы обучили нейросети программировать на Питоне, на C# и так далее. Вот, человеческому опыту. Но это некий такой промежуточный этап. Да, потому что нам больше не на чем учить, мы не можем сразу перейти к следующему этапу, да?
Мы заложили этот человеческий опыт, во-первых, а во-вторых, человеческие инструменты. Ведь все языки программирования, они были созданы для людей, чтобы белковые смогли каким-то образом там процессору свои мысли передать. А для нейросети-то это костыль. Мы, нам не нужен ни синтаксический сахар, ни это вот понимание. Нейросети могут на каком-то более абстрактном, глубинном уровне программировать.
И я думаю, что мы в программировании тоже придём к этому этапу, освободимся от человеческого опыта, и программирование нейросетями оно ускакнёт резко вверх, как во всех других областях. Так вот, к чему это я говорю? К тому, что нам желательно не перекладывать наши старые подходы, как мы привыкли делать, на то, что теперь за нас делают агенты. Если мы, как люди, делаем среду, мы её делаем по всем тем же подходам человеческой работы.
А если софт создаётся внутри среды агентами, вот туда перекладывать MVP-подход, допустим, там тот же не нужно.
Кто проверяет проверки
Владимир Гриненко. Если мы говорим, что мы перекладываем тогда эти итерации и MVP-подход на создание среды, то в какой момент мы можем начать доверять тому, что внутри среды генерируется, если она постоянно меняется и мы постоянно не уверены, что очередное изменение не приводит к тому, что агенты теперь будут или снова продолжат, или там начнут творить дичь, которую раньше не творили.
Руслан Сафин. Угу. Хороший вопрос. Но здесь всё упирается как раз в метрики качества, как мы оцениваем результат на выходе. Мы же можем вообще с разных сторон подойти. Если мы говорим, что вот сейчас у нас на выходе какая-то простая система, там с небольшим количеством сценариев, мы можем обойтись только какими-то функциональными тестами. Заложить бизнес-сценарии и сказать, что если они работают, то всё хорошо, там не так, не так важно, какая у тебя архитектура внутри, качество кода и так далее.
У нас вот действительно какая-то первая итерация стартапа, у нас не будет высоких нагрузок, и главное, чтобы всё работало вот по бизнесу-правильла. Правильно. Потом мы развиваем нашу среду, закладываем туда какие-то архитектурные решения, всё больше неких направляющих, стимулов. И у нас постепенно наш конечный результат, он подрастает в том числе, в нефункциональных требованиях.
Мы начинаем держать большую нагрузку, можем работать с большим количеством данных, там, быстрее, не знаю, видео на входе обрабатывать и так далее. Я сейчас фантазирую. Ну и плюс, когда опять же, мы закладываем малое количество бизнес-сценариев, у нас софт, простой, в нём нету некой этой вот сложности. Вся эта сложность нарастает. А именно с разветвлением различных бизнес-сценариев, с появлением новых модулей и так далее.
Когда у тебя три сценария, не знаю, happy path и два ошибочных сценария, тебе очень сложно написать плохой код просто потому что его супер мало. А именно качество кода, оно выстреливает и выходит на первый план, когда у тебя софт становится сложный с точки зрения бизнеса. Потому что сложность бизнес-сценариев, она мультиплицируется в сложности кода, в несколько раз. И это, оно играет роль и на людской разработке, и на агентской разработке.
Потому что агенты пока точно так же они читают код, и если он весь лапшеобразный, то они тоже. С трудом его понимают и делает его ещё более хрупким и допускают ошибки. Качество кода пока вот на данном этапе, оно важно и для разработки агентами в том числе. Я бы, наверное, так ответил на вопрос, что у нас постепенно усложняется и сама среда, и результаты выхода. Естественно, на простой среде, когда мы только-только MVP-среды написали, мы не сможем сразу какую-то там ERP-систему завода на ней создать, чтобы учитывалась тысячи сценариев.
Владимир Гриненко. Так, а всё-таки проверка бизнес-сценариев — это то, что находится на уровне среды? Или это всё-таки внутри среды тоже должно генерироваться по правилам среды?
Руслан Сафин. Внутри среды агенты создают разные варианты софта и, естественно, они должны иметь возможность запускать любые проверки, в том числе технические проверки на архитектурные метрики. Технические юнит-тесты и end-to-end-тесты проверяющие именно бизнес-сценарии. Потому что агентам нужно тоже понимать, правильно они двигаются либо нет. Единственное различие, что изменять эти проверки, как мы уже обсудили, они не могут.
Ну и как оператор среды либо средовой инженер, когда приходит и видит результат, смотрит результат, он видит результаты всех этих проверок. Допустим, у нас есть 20 end-to-end-тестов, на бизнес-функционал, что вот сейчас 18 пройдено, а 2 упали по таким-то причинам. Это вот метрики, на которые смотрит в конце человек и который принимает решение. Условно, там, опровить, не опровить, вносить изменения в среду либо вносить изменения в функциональные требования на входе.
Владимир Гриненко. Если мы внесём сам код этого end-to-end-теста на уровень среды то, мне кажется, система вообще никогда не заработает, потому что любое изменение будет даже позитивное, правильное и ожидаемое, будет влиять на этот НТН-тест. И будет его валидно ронять, а у агента не будет возможности его починить, он будет запускать эту проверку и видеть, что всё красное, биться лбом об стену и никогда не закончится.
Руслан Сафин. Так, а почему, если у нас правильное изменение в среде, почему тест тогда не проходит?
Владимир Гриненко. Ты говоришь такое, что вот мы настроили среду, какой-то там средовой инженер говорит: «Всё, я сделал, среда гарантирует правильность работы внутри софта. А потом мы принимаем какое-то продуктовое решение, которое вносит изменения, и это изменение, мы заранее понимаем, что да, оно, конечно, сломает предыдущие тесты, но оно нам нужно. И вот мы внутрь среды говорим: «Вот нам такие требования поменялись, примени их».
Он меняет код и нужно либо заранее, значит, на уровне среды позаботиться о том, чтобы переписать все тесты под ещё несуществующую фичу, и тогда у нас сломано типа до начала разработки. Или мы должны разработать, и тогда у нас сломано после разработки, но доступа починить тесты у нас нету. Короче, нестыковочка.
Руслан Сафин. Угу. Да, я понял. Смотри, я стараюсь разделять различные метрики. Есть метрики, которые общие и не зависят от бизнес-требований, это вот как раз технические метрики, это тесты на соблюдение архитектуры, это технические метрики, там того же статического анализа кода, там количество зависимостей и так далее. Это то, что не зависит от бизнес-требований. И второй тип метрик и проверок — это, вот функциональные, либо проверка бизнес-сценариев.
Естественно, если у нас меняются требования на входе, то у нас должна поменяться проверка. Они меняются синхронно. Не может быть, что сегодня не знаю, допустим, мы могли в интернет-магазине заказывать максимум 10 кг товаров, и это есть в проверке. Завтра мы увеличили этот лимит до 20 кг и не изменили тест, который это проверяет. Это невалидно, и эти вот требования и тесты, которые проверяют эти требования, они синхронно должны одновременно меняться.
Это какой-то отдельный уровень вот проверок, -, там среды. И тут ещё один момент, в среде вот всё, количество попыток, варианты попыток, они всегда ограничены. Условно, мы не можем бесконечное время давать агентам и бесконечно жечь токены. У каждого какой-то итерации реализации есть лимит попыток. И если там внутри среды агенты, вот ты правильно говоришь, бьются в лоб об какую-то проверку, условно, не могут соблюсти архитектурные правило, либо не могут пройти функциональный тест, они тратят какое-то лимитированное количество попыток, и потом просто загорается некий аллерт.
Вот средовой инженер, смотри, я тут и так, и сяк попробовал, вот столько-то лимит попыток выжрал, у меня не получается пройти это и это. Тут, возможно, проблема, возможно, ошибка в настройках среды. У нас просто какая-то одна метрика настроена так, что она никак не выполнится при второй метрике. Потому что когда мы настраиваем, у нас же обязательно должны быть балансирующие метрики.
Иначе у нас получится, как в том эксперименте со скрепками. Есть идеальный создатель скрепок, который создаёт скрепки из всего того, что есть вокруг. И в определённый момент он перерабатывает всю Землю, включая биомассу, потом там Солнечную систему, Галактику, и всё во Вселенной только скрепки. Так вот, если задать агенту у него неправильное правило, неправильный стимул то у нас может получиться то же самое.
Любая метрика, она, как правило, имеет ещё и балансирующую метрику. Мы должны обрабатывать там видео до 10 ГБ, но балансирующая метрика, при этом, что мы должны её обрабатывать за там максимум, не знаю, 30 секунд, к примеру. Это такие больше нефункциональные штучки, но и у бизнес-метрик, всегда должны быть какие-то некие пары. И если их неправильно задать, то да, может получиться так, что мы не можем попасть в целевую метрику и соблюсти одновременно балансирующую.
И это ошибка именно создания среды, и агент после нескольких итераций упирается в некую квоту и говорит: «Всё, типа, я всё израсходовал, пожалуйста, посмотри там настройки. Зовёт садовника».
Владимир Гриненко. Мне здесь кажется, что самая сложная часть — это нащупать правильную границу, где, ты, часть тестов кладёшь внутри среды, и они меняются под каждое изменение агента, и агент сам решает, что можно эти тесты трогать, потому что поменялись бизнес-требования. А какие тесты должны остаться недоступны этому агенту. И вот сейчас мне кажется. Понятно, что и методология — такая некая абстракция, но вот-именно здесь, мне кажется, если придумать хорошие ответы на это, она действительно может начать прямо сильно помогать.
А без этого она всё равно как бы не отвечает на те как раз головные боли, которые у разработчиков каждый раз и возникают.
Руслан Сафин. Смотри, с одной стороны, мы сейчас, говорим несколько абстрактно, и я про это даже размышлял абстрактно, пока до меня в один день вдруг не осенило. Я потому что параллельно там у себя в компании мы разрабатывали свой SDD-фреймворк и harness и продолжаем разрабатывать. А потом до меня вдруг дошло, что harness — это и есть вот эта среда. Мы некая обвязка, которой мы управляем и направляем агентов.
Понятно, что одним Харнесом не обойтись. Надо ещё вот то, что мы сейчас проговорили, некие там законы, стимулы, направляющие и так далее. Но вот, по сути, вот Харнес — то, чем многие сейчас занимаются, это и есть вот как раз реализация средового подхода, уже перекладывание не на абстракцию. Возвращаясь к твоему вопросу, в целом Я могу рассказать, как я это решаю. Допустим, я делаю вложенные репозитории, там, у меня есть папка, в ней под папка с другими репозиторием, в ней подпапка там с третьим репозиторием.
Я работаю во внешних репозиториях, в надпапках, над средой, над харнесом, а внутри, уже агенты внутри этого харнеса либо внутри этой среды работают над конкретными проектами. У меня в канале даже есть пост про, как это организовано. Но я не хочу скорее акцентировать на этом внимание, потому что мой сейчас основной посыл, чтобы индустрия задумалась вообще вот об этом новом подходе, об этой методологии.
Я ни в коем случае не претендую на полноту, я хочу именно сделать некий черновик, некий шаг, и, на мой взгляд, наша задача, вот как индустрии в целом — начать прорабатывать эти вот принципы, подходы и саму методологию. Потому что все мы этим занимаемся, но без какой-то методологической базы. И вот с этой точки зрения, если я буду говорить про конкретные реализации это скорее может, не то чтобы сбить, а, как сказать?
Направить не на тот путь. Я думаю, много людей придумают, как гораздо эффективнее реализовать эти там принципы, вот ти подходы, как я говорю. А если я буду говорить: «Вот, смотрите там папку, кладите в папку, и тогда у вас будет здесь хе уровень тестов среды, а здесь уровень тестов внутри среды, это уже конкретная реализация. А я сейчас как раз хочу именно на уровне вот некого подхода, чтобы мы все это сформулировали, мы все попробовали разные уже реализации, и потом кто-то выступил с подходом, с докладом и сказал: «Вот смотрите.
У меня получилась крутая реализация. А другой выступил с другой реализацией, и у нас уже были разные варианты. Пока я хочу именно на таком немножко теоретическом уровне. Запустить эту волну думания над, поставить саму задачу. Ведь если мы задачу не поставим, никто её не сформулирует, то и ответа на неё не будет ответа на несформулированный вопрос.
Доверие к результату и стоимость среды
Владимир Гриненко. Хорошо, мысль понятная. И, мне кажется, действительно очень назревшая проблема. Но я бы тебя всё-таки помучил с вопросами про конкретику. Давай оставим дисклеймер, что это пока work in progress, и ты это не предлагаешь как единственный верный ответ. Но всё-таки вот яя вижу сейчас из того, что услышал две важные проблемы, и они без приземления на конкретику непонятно, как на них ответить.
Вот первое — это то, что там неважно, то ли это три вложенные папки, то ли как угодно вот разграниченные эти области ответственности. А как мы всё-таки в какой момент можем говорить про доверие суммарно всей этой конструкции? Почему мы всё-таки вот ту задачу, которую изначально ставим, чтобы мочь катить в прод, не глядя? Когда мы сможем сказать: «Вот сейчас можно?» И второй вопрос — это не оказывается ли, что гарантия этой надёжности, она приводит к тому, что вся та сложность, которая раньше лежала внутри проекта, просто поднимается на уровень среды.
И мы теперь там страдаем точно так же, как раньше. Но да, агенты сами катят, но катят какую-то такую простую маленькую тривиальную штуку, потому что всю большую и сложную мы по-прежнему поддерживаем на другом уровне.
Руслан Сафин. Мы, как инженеры, привыкли катить в прод действительно то, чему мы доверяем. Когда мы сами пишем код, мы, проживаем его, мы знаем какие вопросы мы задали аналитику, мы знаем там, чтока написано, какие у нас были мысли. Мы прожили какое-то время с ним, и мы понимаем, как он работает, и можем за него ответить. Либо мы понимаем, что «блин, что-то я тут сомневаюсь в куче местах, он там хрупкий.
Будет заработает только если повезёт. Когда код написал агент, у нас вообще нету каких-то фактов, факторов, на которые можно опереться и там взять ответственность на себя, либо не взять. Точнее, взять ответственность либо за там обрыв, либо за там отмену, и отменить же надо не просто так, а потому что раз-два-три. Сформулировать и обосновать, почему мы это не катим в прод. Так вот, задача среды, средового подхода, на мой взгляд, как раз предоставить решающему, человеку, который берёт на себя ответственность, эти вот некие знания, некие факты, на основе которых он сможет это принять.
С-аредовой подход показывает человеку, ты, как средовой инженер, ты понимаешь, а во-первых, какие законы были заложены в среду, что код точно их соблюдает. Ты видишь метрики, и технические метрики, и качество кода, и количество там бизнесовых бизнес-метрики в плане количества пройдённых функциональных тестов. Ты понимаешь, что если они пройдены, то это действительно так, и агенты внутри не смогли тебя обмануть.
И если ты понимаешь устройство среды, ты уже на основе этих видимых результатов, измеренных результатов, уже принимаешь решение, там нажимать Approve либо запросить какую-то дополнительную проверку, дополнительную метрику и так далее. Моя идея в этом. Среда должна тебе показать метрики, а ты как инженер, который знает, как устроена среда, уже им веришь, и на основе их обосновываешь.
Ты не знаешь, как сделан сам конкретный результат софт, но ты знаешь его метрики и знаешь, как эти метрики условно, собирались и были сделаны. Это что касается первого вопроса.
Владимир Гриненко. Второй про сложность. Вот мы, допустим, решили, покрыли всё правильными метриками, обложили всё тестами, но теперь нам нужно эту всю часть продолжать уверенно, надёжно и для каждого изменения своевременно поддерживать, не окажется ли, что это примерно по трудоёмкости похоже на то, что было раньше?
Руслан Сафин. Похоже точно не окажется, это будет сложнее. И это хорошая для нас новость. Потому что если бы сложность нашей деятельности не росла, то нас бы давно всех заменили. Мы же все там переживаем, что нас там заменят агенты. Раньше переживали люди, что они всю жизнь копали лопатами, и там заменят экскаватор и так далее. Естественно, мы должны брать на себя всё больший масштаб деятельности.
Да? Если раньше 100 человек копали лопатами, то сейчас один водитель экскаватора там сделает за день в, наверное, на порядок больше, чем 100 человек с лопатами. Так вот, и тут всё то же самое. Средовой инженер он создаёт среду, которая создаёт софт, во-первых, гораздо быстрее, да? создаёт больше софта и создаёт, решает не конкретную задачу, а решает целый класс задач. Мы создали среду, и она уже потом не только то, что там бизнесу нужно сейчас делать, но и то, что понадобится завтра-послезавтра.
А ещё и, возможно, целый класс таких задач она будет решать. Масштаб деятельности должен расти, на мой взгляд. Иначе у нас, иначе мы будем неконкурентоспособны в условиях постоянного развития технологического, технического прогресса. И--и, создавая среду, мы ускоряем тайм-то-маркет, ускоряемк, количество, софта, который мы поставляем в прод. И решаем не конкретную одну задачу, а уже там целый класс задач.
В этот идея моя в том, что да, рост сложности, он компенсируется именно масштабом решения задачи.
Владимир Гриненко. Тут у меня какое-противоречие с тем, что ты, с одной стороны говоришь, что на уровне среды должны быть зафиксированы в том числе бизнес-требования. А с другой стороны, что она достаточно универсальная, чтобы решать целый класс задач. Вот мне кажется, что это взаимоисключающее утверждение.
Руслан Сафин. Угу. Тут вопрос в том, кто задаёт эти требования. Если их задаёт бизнес, тут уже мы можем обойтись без средового инженера. Мы настроили среду, отдали аналитикам, отдали бизнесу. Роль аналитика тоже пока спорная в нашем IT-будущем. Отдали кому-то, кто формирует эти бизнес-требования. Возможно, это и агент бизнеса. И он уже с этим работает. Он меняет требования на входе, и у тебя среда вносит изменения в текущий продукт, либо создаёт новый продукт по этим требованиям.
И ты, как средовой инженер уже практически с этим не работаешь. Тебе нужно подключиться, если там, услов, какой-то аллерт от среды пришёл, либо какая-то проблема. Вот бизнес-требования, они немножко, наверное, чуть в стороне. Это отдельная, такая там фича, с которой работает не средовой инженер, а кто-то из бизнеса.
Владимир Гриненко. Ну всё-таки бизнес-требования тогда должны и их проверки должны храниться внутри среды, правильно?
Руслан Сафин. Ну здесь вот, здесь, наверное, у меня нету однозначного ответа, как это организовать. Внутри среды, возможно, есть там разные уровни. Что задаётся там бизнесом, что задаётся не. Тут вопрос, наверное, мне кажется, больше к реализации. Понятно, что самый главный подход, что требования на входе должны соответствовать функциональным тестам на выходе. А как это организовать: внутри среды?
Или это какой-то слой над средой или рядом со средой? Тут, мне кажется, это уже ближе к реализации. Однозначного ответа у меня тут нет.
Универсальная среда и возможности моделей
Владимир Гриненко. С одной стороны, мы так и не добили даже базовые термины, с другой стороны, интересно спросить про можно ли представить себе ткую среду, которая будет достаточно универсальна, чтобы в ней можно было делать не любого масштаба интернет-магазин. А вообще любой софт. Вот сегодня мне нужен Telegram-бот, завтра мне нужна CRM, послезавтра мне нужен новый язык программирования. И вот я один раз так хорошо устал и поработал над средой, что теперь я просто вот туда закидываю любое пожелание, и оно уверен гарантированно К утру в продакшне.
Руслан Сафин. На самом деле, мне кажется, мы, не то чтобы к этому идём, но отчасти оно уже есть. У нас есть там Opus, есть, ChatGPT-модели. У них внутри есть свой harness, там свои системные промпты и так далее. По сути, у них внутри есть некая среда, в которой они универсально пишут код. Но этого мало, там же сейчас мы разделяем на L1, L2, L3 харнесы, уже более конкретные под конкретную компанию, под конкретный домен и так далее.
Даже внутри, насколько я знаю, там антропика, есть разные, -а, не то чтобы нейросети, разные обвязки для юристов и разные обвязки для медицины для написания кода. И, мне кажется, вот мы идём в эту сторону, что есть некая общий харнес либо общая среда на уровне поставщика модели, она универсальная для написания, допустим, любого кода. И есть более конкретные среды, которые, каким-то образом ограничивают и направляют более узко, да?
И таких харнесов либо сред наверняка может быть много уровней. Уже сейчас их минимум три уровня. И тут, мне кажется, хороший пример в том, что и раньше мы, у нас не было универсальных паттернов. Мы под каждый конкретный проект брали свои паттерны и принципы, там проектирования, программирования, которые подходят конкретно под наш случай. Нет такого, что этот, эти наборы принципов нужно соблюдать в любом проекте, да?
И они обязательно нерушимы, и всё по-другому, ну. Иначе мы напишем плохой софт. А если бы так было, то у нас бы уже давно, даже без нейросетей был бы какой-то детерминированный организм алгоритм, который пишет хороший код. Либо говорит, что красная кнопка, код плохой, там зелёная, зелёный индикатор код хороший. К сожалению или к счастью такого нет. И мы под каждый конкретный сценарий, под каждый конкретный там проект строим свою архитектуру и как в корзину, в обычном магазине набираем, что: «Ага, этот паттерн мы возьмём, этот будем использовать, а этот нам ни к чему», мы, оставим его на полке.
И исходя из этой мысли, я думаю, что вот всё-таки у нас будет несколько уровней. Универсальная среда широкая и несколько там сред, там слэш-Харнесов, более узких под конкретную, там направленность деятельность конкретной компании. Пока-пока, на мой взгляд, так. Но это больше какой-то прогноз, взгляд в будущее, как на самом деле, куда мы придём, я думаю, сейчас никто не знает.
Владимир Гриненко. Если проследить, как эволюционируют Харнесы от фронтирных лабораторий, то они действительно очень сильно усложняются и очень быстро меняются, но как раз по мере того, как это универсальный уровень Харнеса развивается, отмирают все вот те костыли, которые на следующих уровнях было необходимо дополнительными какими-то подпорками добавлять. И по мере улучшения и развития моделей то же самое.
Если раньше наХли нам нужно было модель прямо за ручку вести, иначе она начинала косячить, то теперь скорее наоборот. Чем меньше задаёшь заранее ограничений, тем лучше она сама подберёт под твою задачу подходящий стек, примет правильные архитектурные решения. И тут скорее уже опыт разработчика начинает вредить. Он знает только про то, что он знает, а модель знает про всё вообще.
И она бы могла, если ей никакой вкусовщины не привнести, выбрать лучшее, а разработчик выберет знакомое.
Руслан Сафин. Здесь у меня тоже есть различные рассуждения на тему того, как наша деятельность как программистов меняется. Вед действительно ещё не знаю, несколько месяцев или год назад все говорили про промпт инженера, что главное — правильно сформулировать промпт. Потом появились скиллы, и сказали, что промпт— уже там прошлый век, уже там не- мешай модели работать, она сама лучше знает, главное там, ну какие скиллы, как ты их напишешь?
Там skill engineer, потом контекст-инженер появился. Самое главное, какой контекст туда вкладываешь и так далее. Но, на мой взгляд, все эти вот названия, вся эта деятельность, она направлена именно на прямую работу с ИИ-агентом. Как ты прямо в агентской разработке с ним работаешь? Какиеп промпты даёшь, контексты, скиллы и так далее. Это всё и дальше будет меняться, эволюционировать.
На мой взгляд, именно среда и средовой инженер, он немножко на уровень выше. Он несколько абстрагируется от и агента, который внутри, и он задаёт некие внешние проверки, там, те же архитектурные тесты, те же метрики кода и так далее, там функциональные тесты, которые уже стоят немножко над. Он вообще не говорит агенту, как работать. Он не говорит ему конкретные промпты, конкретные там скиллы.
Он в целом говорит, что вот, требование, вот то, что должно, функциональный тест, который ты должен пройти. И вот какие-то там направляющие, архитектурные метрики и так далее, которые, либо надо строго соблюдать, либо желательно соблюдать. А внутри агенты, они, естественно, эволюционируют и растут. Наверное, с какого-то момента, допустим, не знаю, тот же антропик выпустит новую Я сейчас фантазирую, новую модель, которая будет всегда соблюдать архитектурные тесты, ой, архитектурные паттерны, всегда будет идеально архитектуру проектировать.
Да, возможно, в среде нам что-то понадобится отключить. Мы поймём, что это теперь больше не нужно, оно и так всегда работает. А может, такого и не произойдёт. А может, наш взгляд как архитектора с антропиковским не совпадёт. И мы поймём, что конкретно для нашего проекта нам нужно не знаю, ходить в 10ть баз, а не только в одну каждым микросервисом. Тут опять же ещё раз,-моя идея, мой взгляд в том, что не надо конкретно упарываться в агента, нужно более абстрактно подойти к некой платформе, к некой к неким условиям работы, в которых они работают.
А сами они уже, естественно, будут эволюционировать, всё более умные и умные. А всё более лучше будут писать код, но вопрос даже больше не в этом. Вопрос ведь в том, вот как мы с тобой обсудили, как нам, как принимающим решение нажимать зелёную кнопку, как нам доверять? Если у нас не будет этой вот обвязки, там, метрик, понимания, что мы, какие тесты прошли, какие проверки прошли, какие нет, у нас не будет кнопки.
Не будет, фактов, на которые, на основе которых мы можем взять ответственность. Получается, мы будем верить только каким-то рекламным материалам антропика, что он скажет: «Вот Fable 10, теперь абсолютно никогда не ошибается». Всё, можете использовать и никогда её не проверять. Вряд ли мы с тобой поверим. С первого раза точно.
Кто такой средовой инженер
Владимир Гриненко. Средовой инженер — это специализация, которая вырастает из разработчика или скорее из QA-автоматизатора.
Руслан Сафин. Угу. А на мой взгляд, сейчас уже сейчас, наверное, особого разделения такого нет. Ну и в будущем оно будет только больше стираться или как-то преобразовываться. Вот если сейчас, даже поговорить с бигтехами, не то чтоы там с какими-то стартаперами, новые команды уже собираются из, ну двух-трёх человек. Некоего инженера, который отвечает за технику и некоего там продакт-оунера, который отвечает за интерфейс, за взаимодействие с пользователем и продуктовые гипотезы.
Вот, а опять же, этот, это разделение на специализации, там, аналитик, разработчик, бэкенд, фронтенд, QA, там, DevOps и так далее, оно взялось из нанашего цикла, человеческого цикла создания программного обеспечения. А сейчас мы не должны, на мой взгляд, перекладывать этот подход человеческий на новую нашу деятельность. Во-первых, мы не должны перекладывать их на агентов, что условно у тебя есть агент-аналитик, агент-разработчик, агент QA.
С другой стороны, мы не должны сохранять это вот разделение специализации на нас самих. То, что мы теперь работаем с агентами. Условно, есть некий инженер, который отвечает и за разработку агентами, и за тестирование агентами, и за, не знаю, возможно, там эксплуатацию, DevOps-части вместе с агентами. Возвращаясь к вопросу, я бы не стал говорить, что там конкретно из QA растут и инженеры, скорее из программистов-айтишников.
Первым этапом вот стирается эта, сотрётся это вот это разделение на специализации,е, к которому мы все привыкли. А уже дальше, либо одновременно с этим мы перейдём там к средовому инженеру, ещё к какому-то инженеру и так далее. Может, это один и тот же процесс, который вот и сотрёт разделение компетенций.
Владимир Гриненко. Звучит так, что такой инженер — это по сути CTO вот той области, в которой он оказался каждый раз.
Руслан Сафин. А я так и говорю, если раньше какой-то навык, допустим, делегирования, управления кем-то, он нужен был тимлидам, техлидам, CTO и так далее. То сейчас, по сути, каждый, кто работает с ИИ-агентами, он уже должен иметь навыки делегирования, какой-то там декомпозиции, асинхронной работы и так далее. Потому что у тебя уже есть какие-то исполнители.
Владимир Гриненко. Как раз говорю, что это скорее CTO, чем просто тимлид, потому что ещё и получается мультиспециализация у тебя. Ты делегируешь в агентов, которые в прошлом мире были бы вообще в разных командах и отвечали бы за разное. А сейчас в одной голове оно всё должно как-то умещаться, это вот уровень уже всё-таки не тимлид, а CTO оказывается внезапно.
Руслан Сафин. Если так говорить, то получается, что каждый из нас должен стать или уже стал CTO.
Владимир Гриненко. Звучит, как будто бы, да. Ладно, хорошо, вроде на этом этапе. Да.
Руслан Сафин. Да, звучит так, что бойтесь своих желаний. Кто всегда мечтал? Вот оно и исполнилось.
Стимулы, ниши, границы и следы
Владимир Гриненко. Да. Вроде на этом этапе текущие вопросы понятны. Давай попробуем всё-таки добить термины на примере того бедного интернет-магазина, от которого я всё убегаю в сторону. А мы чуть-чуть про законы успели понять, что это, Давай дальше по терминам пройдёмся.
Руслан Сафин. Да, но опять же, список терминов — это некий первый шаг, это некий черновик, тоже я не претендую на полноту. Да, мы-поговорили про законы. Если говорить дальше, то да, тоже отчасти уже проговорили, есть некие стимулы либо градиенты. Да, во всём многообразии вариантов сгенерированного кода мы должны агента направлять, подсказывать, что этот вариант чуть лучше, чем предыдущий и так далее.
Если говорить про этот примитив, тут точно должны быть некие технические метрики, качество кода, там, качество архитектуры, количество, например, те же количественные метрики, coupling, cohesion, насколько у нас там сложность кода растёт либо не растёт. И в том числе некие функциональные требования либо тесты. Если у нас достаточно сложное ПО должно получиться, то вряд ли мы сразу пройдём там все, допустим, 100 функциональных тестов.
И в процессе работы агента мы должны итеративно двигаться по удовлетворению этих тестов. И здесь опять же, тоже может стать метрикой, которая подталкивает, направляет агента, количество пройдённых именно функциональных тестов. Я к тому, что если там на какой-то итерации мы там естественно, все функциональные тесты не прошли, это не стопит агент, это ему подсказывает, что: Ага, мы там двинулись по сравнению с прошлой реализацией, либо мы наоборот, немножко регрессировали., условно, у нас проходило 50 тестов, а теперь проходит 45 по каким-то причинам.
Тут агент понимает, что движется неправильно, а нужно в какую-то другую сторону двигаться. Это что касается законов и стимулов. Дальше есть связанный примитив — это отбор, про это тоже отчасти поговорили. Это вот как раз тот этап, когда мы отсекаем все неподходящие варианты. Чем раньше мы это сделаем, тем, соответственно, солт будет быстрее агентами написан, и меньше токенов мы это сделаем.
Это этап, когда некая популярность, некий, некое количество вариантов проходит через все эти вот тесты, все проверки и так далее. И ещё один важный момент — это то, что нам желательно проверять метрики на некое популяции результатов. Так как у нас процесс создания софта недезерминированный, у нас может получиться, что мы, получили некий результат, и он удовлетворяет всем метрикам, и всё идеально и хорошо.
Но это не обязательно означает, что у нас хорошо и круто настроена вся среда. Нам могло просто повезти. Нам один раз повезло, и у нас все метрики сошлись, все метрики крутые. Не знаю, звёзды так повернулись, что агент с первого раза всё создал. Поэтому метрики нам нужно замерять на некой серии результатов, на некой популяции, а не на конкретном одном случайном выбросе. Следующий момент, про который ещё не поговорили, — это ниши.
Вот ниши — это как раз примитив, такая часть из классического средового подхода, который есть вот в разных, как я говорил, там сферах. Ниша — это некое если перекладывать на IT, опять же мы с этим много где сталкивались. Это любые точки расширения, это некая плагинная структура. Когда мы делаем некий софт и делаем возможность к нему плагинами логинами что-то подключить. Ниша — это заранее подготовленный некий участок, где мы можем нарастить новый функционал, добавить новую интеграцию и так далее.
Тут, наверное, отличие от стандартного какого-то просто там контракта, точки расширения или интерфейса в том, что она должна быть гибкой. Для новой интеграции нам может не хватить старого контракта, старых заготовленных данных. При этом агент в рамках этой там некой свободной пустой ниши, он может чуть-чуть двигаться, он может немножко расширить контракт на необязательные поля и так далее.
Если мы Если очень строго зададим жёсткий контракт, что с нами можно проинтегрироваться, плагин можно написать только определённым образом, это всё-таки будет не средовой подход, это будет натягивание там новой интеграции на старое наше понимание об интеграции. Средовой подход и ниша эта в том, что мы задаём некую базовую часть, некую там, мне нравится аналогия с коралловым рифом.
Мы создаём питательную среду, а коралловый риф он нарастает сам, в определённых каких-то, ну в определённом месте, в определённых границах, которые мы, как не знаю,, как садовники этого рифа задали. Так вот и здесь, в софте, мы задаём некий базовый контракт, базовые данные, которые можно использовать в интеграции, но не ограничиваем слишком строго. При каждой новой интеграции, естественно, мы не можем учестьна будущее все возможные будущие интеграции.
И когда мы её уже реализуем, агент немножко меняет контракт, добавляет новые данные, где-то что-то подтягивает.
Владимир Гриненко. А вот если смотреть на ниши именно в контексте интернет-магазина и вот, допустим, в реализации С теми тремя вложенными папками, про которые ты говорил. Вот что должно лечь в какую папку здесь, чтобы говорить, что вот мы реализовали нишу не знаю, для того, чтобы новых платёжных систем подключать?
Руслан Сафин. В интернет-магазине это могут быть ниши для новых платёжных систем, для новых служб доставки. Мы, допустим, хотим подключить ещё одну, либо платёжную систему, которой раньше не было, либо там службу доставки, либо подключить ещё одного там мерчанта-продавца. Наверное, мерчанта продавца в меньшей степени, потому что они там по стандартному протоколу пойдут. А если мы, допустим, с Яндекс.Доставкой интегрируемся, то вряд ли она будет под наш контракт подстраиваться.
Да, мы задаём некие условия подключения вот неких новых интеграций, которых раньше не было. И причём каждая эта интеграция, она может быть немножко не типовой, а немножко отличаться от того, что было. А если говорить про папки, тут скореебудет это реализация не конкретно, в папках, что где настроено, а в неких тоже правилах и ограничениях. Это можно настроить, например, тестами.
Мы предоставляем некий базовый набор в контракте обязательных полей, которые можно использовать в рамках этой интеграции и говорим, что в качестве можно ещё их расширять какими-то, я сейчас, там немножко фантазирую. Допустим, необязательными полями. Конкретная интеграция может расширять контракт необязательными полями, это ничего страшного. Но мы, допустим, строго ограничиваем, что если У тебя есть какое-то обязательное поле, которое ты должен, допустим, отправить этой новой платёжной системе, и этих данных нету в твоей базе данных, да?
А тебе нужно за этими данными сходить куда-то в отдельную базу данных, не знаю, складскую, зачем-то. То это уже делать нельзя, это всё-таки нарушение границ ниши. Мы описываем, что в рамках реализации интеграции мы можем двигать туда или сюда реализацию, но в пределах каких-то условий. Если, допустим, в базеэ платёжных систем, в твоей базе данных этого адаптера этой интеграции есть такие данные, ты можешь их добавить в контракт, без проблем, там для новой интеграции делай это.
Но если этих данных нет, и тебе нужно не знаю, сходить в чужую базу либо расширить схему базы, у себя, то это за пределами ниши, и тут этого делать нельзя. Получается, либо агент пробует обойтись без этого, построить интеграцию, либо говорит, что «Sorry, alert, не могу». Тут такая интеграция, которая не вписывается в границы, обозначенные в нашей нише.
Владимир Гриненко. А на практике всё-таки это что будет? Это будет какая-нибудь валидация в виде JSON-схемы на этот контракт, где часть полей required, часть полей необязательные и расширяемые. И вот как только мы не помещаемся в эту JSON-схему, агент должен сказать: «У меня лапки».
Руслан Сафин. Гру говоря, и плюс какие-то тесты на там нерасширение базы данных, схемы базы данных. Тут мы уже немножко в детали уходим. Мы говорим, что если ты делаешь новую интеграцию в рамках ниши, то ты не можешь менять схему данных, например. А если ты делаешь какую-то другую функциональность, не внутри вот ниши для платёжный систем нарастаешь, то там можно менять схему данных.
Владимир Гриненко. А как с точки зрения вот того, что мы храним на файловой системе, отличать? Нишу и её констрейны от стимулов и тех ограничений, и от законов и тех ограничений. Это всё выглядит как, если я правильно понимаю, в итоге в реализации набор каких-то тестов, линтеров и так далее. И вот почему одно считается законом, а второе нишей, если технически это примерно всё одно и то же?
Руслан Сафин. Тут мы опять же немножко уходим в реализацию. У меня нету какого-то одного универсального ответа, у меня там под пару проектов, разные реализации этого подхода. Тут я как вижу. Мы, в зависимости от задачи уже понимаем, если мы работаем в рамках ниши, то там же мы можем не только вот ограничивать контракт. Для ниши может быть какой-то шаблон, допустим, интеграции, либо шаблоны репозитории.
Что, ага, если ты добавляешь платёжную систему, вот тебе шаблон, бери его и там на основе него как-то, ну его дорабатывай. У тебя есть шаблонная интеграции, ты её развивай. И тут уже, строгого решения у меня нет. Сейчас есть некий оркестратор, который понимает, что: ага, мы работаем в рамках ниши, поэтому нужно дополнительно добавить эти вот проверки. Но я с тобой согласен, что сейчас это не детерминировано, если там этот оркестратор, ошибётся, и мы будем платёжную систему добавлять, но там не пойдём по правилам ниши, то, строго говоря, снаружи это сейчас не отслеживается.
Это то, над чем ещё нужно поработать. Тут простое, наверное, решение. Если мы понимаем, оператор-инженер понимает, что сейчас нам нужно добавить интеграцию, а у него в метриках не показывается, что это работа над нишей и параметры ниши, он, понимает, что ага. Что-то задача не соответствует тому, как всё-таки внутри у нас наросло, нарос некий код.
Владимир Гриненко. Давай такой тогда вопрос, что верно ли, что эти термины — это скорее такая абстракция, чтобы помогать средовому инженеру об этом думать, чем какая-то техническая реализация для агентов. Агенту скорее эти термины не нужны.
Руслан Сафин. Да. Да. Это точно так. Это именно термины проектирования среды. Как нам проектировать среду. Какие у нас есть примитивы, возможности, что мы можем добавить?
Владимир Гриненко. Так, ну и кажется, у нас ещё из неразобранных что-то осталось из базовых терминов.
Руслан Сафин. У меня есть, на самом деле, несколько версий базовых терминов. Вот последние, на чём я там остановился, более такие, наверное, сформулировавшиеся. Мы из них то не разобрали законы, разобрали, законы и границы для меня сейчас — это плюс-минус одно. Их можно разделить, законы — это то, что мы поговорили, некий аналог физических законов. Границы — это если мы чётко сами уже на уровне архитектуры разделяем на компоненты, либо на ограниченные контексты.
Можно это опять же использовать, можно не использовать в зависимости от того, мы хотим, ну лольчше сами спроектировать архитектуру, либо мы отдадим на уровень агентов. На мой взгляд, это зависит от конкретного проекта, от конкретной среды. Где-то мы закладываем архитектуру, где-то мы отдаём внутрь. Граница относится вот к уровню там нарезки компонентов и микросервисов. Дальше мы поговорили про ниши, проговорили про стимулы, проговорили про отбор.
По-моему, про базовое всё проговорили. У меня в статье там чуть больше примитивов задано, но я, возможно, от там части из них откажусь.
Владимир Гриненко. Бритва Оккама в действии.
Руслан Сафин. Да, я вспомнил, мы не проговорили про ещё один интересный очень, как это, примитив средового подхода, который тоже есть в средовом подходе, там в любой области. — это стигмергия. По-моему, надеюсь, не ошибся в термине. Это. Давайте, мне очень нравится этот пример. Представим муравейник. Если издалека на него посмотреть, там кажется, что творится хаос. Куча муравьёв, чё-то делают.
Но если присмотреться, там всё очень хорошо организовано. Часть муравьёв идут в одну сторону за какой-то едой, там часть муравьёв несут это обратно, кто-то ещё что-то строит, куда-то что-то несёт. Так там тысячи и миллионы муравьёв каким-то образом организованно всё делают, но У них же никакого Zoom-созвона на весь муравейник нет. Как они вообще друг с другом синхронизируются?
И нет некоего оркестратора, либо там менеджера, который каждому говорит: «Вот тебе делать это». Да, и при этом весь муравейник живёт. На самом деле они оставляют некий химический след за собой, там феромоны, которые подсказывают следующему идущему муравью, идти туда либо не идти, что делать. И таким образом, по этим следам и организуется вот в общем, в целом работа муравейника. На самом деле этот подход тоже применяется, там отчасти тот же event sourcing, отчасти это тот же подход, когда мы оставляем только следы изменения.
И гит-репозитории тоже примерно туда же и так далее. Так вот в средовом подходе, часто это используется. И если мы работаем несколькими параллельными агентами или даже на самом деле одним и тем же агентом, у которого периодически контекст сбрасывается, у него там память теряется по щелчьку. И он смотрит, вообще пытается сориентироваться, где он находится. Обязательно должны быть некие эти вот артефакты, следы, по которым все синхронизируют и направляют свою работу.
Нет некоего общего оркестратора, который управляет там всеми агентами, но есть чётко заданный формат. Мы записываем, какой агент какую работу взял, чтобы не делать её параллельно, каких результатов достиг, что попробовал. «Я попробовал реализовать так. Там всё плохо, метрики плохие, туда не ходите». Да, чтобы у нас повторно не было такого, что одни и те же ошибки агенты постоянно повторяют.
Да? И вот эти артефакты, они должны быть в строго определённом формате, и все должны их понимать. Это мы прямо уже реализовали в нашем Харнесе, и это очень сильно улучшило качество. Всё, теперь, наверное, точно все эти вот подходы, примитивы, которые я сейчас рассказываю и советую всем использовать, я рассказал.
Как исправлять ошибки и развивать среду
Владимир Гриненко. Давай тогда попробую ещё разных уточняющих вопросов вокруг позадавать из того, что пока оставляет некоторые белые, как мне кажется, пятна. По крайней мере, для меня пока они не очевидные. Вот, допустим, мы создали среду, внутри неё с неистовой скоростью нагенерировали огромное количество какого-то софта. И он опирался вот на все эти описанные законы и так далее по списку. В какой-то момент мы понимаем, что в самой среде нужно внести вот какие-то фундаментальные изменения и поменять то, на чём базировалось всё остальное.
И после внесения этих изменений вот весь этот огромный набор софта, который был построен, он как-то инвалидируется, и мы теперь его переизобретаем.
Руслан Сафин. Да. Отличный вопрос, и там про это можно порассуждать. Если нас устраивает вообще старая версия софта и она работает, и никаких проблем с ней нет, то, что работает, старый наш принцип работает, не трогай. Можно его и не переписывать. Если как раз какое-то новое знание, новый инцидент, влияет, и мы понимаем, что блин, там везде есть ошибка, ». То, наверное, да. Наверное, надо весь этот солт переписать.
Но сейчас многие говорят о том, что сам код — это уже не является ценностью. Сам код можно переписывать хоть каждый день. Да, есть прямо несколько статей, докладов на эту тему, что код перестал быть ценным, а ценны не знаю, какие-то сценарии описанные, бизнес-требования, по которым можно хоть каждый день код переписывать и перевыкладывать в продакшн. И тут ещё один важный момент, как мы вообще меняем среду.
Допустим, мы выпустили что-то в продакшн и мы наткнулись на какой-то критический инцидент. В целом, если это критический баг, мы, естественно, можем хотфиксом сами залезть в код и, условно, переписать if. Но в средовом подходе мы должны понять, - из-за чего вообще агент совершил такую ошибку. Какого условия ему не хватило, какого инструмента, каких там данных, контекста. И мы идём и потом пробуем, -а, изменить, подкрутить параметры среды, метрики, пробуем запустить ту же самую задачу и смотрим, что эта ошибка не воспроизвелась.
Мы залезаем в код только тогда, когда нужно сделать срочный фикс. Да? А если это несрочно, мы даже там в код не должны лезть. Мы должны подкрутить среду так, чтобы агент сам эту ошибку исправил и, больше никуда не допускал. Потому что если мы каждый раз будем в код лезть и исправлять ошибку, то эта ошибка будет повторяться в будущем, потому что мы условия-то не поменяли.
Владимир Гриненко. А если говорить про такое развитие среды и аналогию с еловеческим флоу. Обычно бывает так, что у тебя есть что-то, что мы там можем назвать средой. И есть команда, которая этой средой пользуется, у них каждый день где-то что-то жмёт, болит и мешает, и они снизу В либо там платформенную команду, это приносяит как репорт, либо ещё как-то. Но, в общем, изнутри среды идёт сигнал наружу, что надо менять среду.
А в данном случае получается, вот агенты связаны по рукам ограничениями среды, но у них же нету никакого способа сказать: «Нам среда мешает делать хорошо».
Руслан Сафин. Да, тоже хороший вопрос. Сейчас, наверное, немножко с другой стороны мы к этому пришли, но М к этому пришли. У нас в нашем Харнесе есть прямо регулярная задача, для агентов, как сказать. Мы это называем саморефлексией. Он должен раз в период времени запустить этот специальный скилл, этот там специальный, там скилл плюс, какой-то скрипт, и проанализировать всю свою работу и сказать, что было хорошо, что было плохо, какие ошибки он, повторялись.
И мы получаем от него эту самую рефлексию и на основе неё принимаем решение. Он может в своих рассуждениях несколько раз зайти не туда, а мы об этом даже никак не узнаем. Он там пожёг токенов, да, и нам бы очень хорошо это знать. И этот регулярная задача по саморефлексии, она прямо очень, эффективная, на мой взгляд. Кстати, может, даже это надо прямо явно где-то мне добавить.
В принципах среды, что опрашивать агентов и на основе этого уже вносить какие-то изменения. Да, это хорошо, что мы сейчас поговорили, у нас это уже есть, но я как-то про это не задумывался. Мы это сделали, пользовались, но почему-то у меня не щёлкнуло.
Владимир Гриненко. Значит, не зря мы разговариваем.
Руслан Сафин. Да. Точно не зря.
Владимир Гриненко. Если у тебя уже есть какое-то количество реализации этого подхода, можешь ли ты на своём опыте сказать, что он себя окупает? Или это всё-таки пока скорее такое больше исследовательская история, и рано говорить уверенно?
Руслан Сафин. Сказать, что прямо у меня всё это работает в конвейере, я, к сожалению, пока не могу. Скорее, у меня есть на разных проектах некие частичные реализации, там части этого всего. Но мы работаем над вот как раз общим Харнесом, который используем на будем использовать, уже используем и будем использовать на разных своих проектах. В плане экономической окупаемости, вот наверное, хочется поставить такой эксперимент.
Надеюсь, у меня там будут ресурсы и хватит времени сделать, взять какую-то небольшую задачу, условно, там, если говорить про наш интернет-магазин, там взять и подключить какую-то платёжную систему в рамках средового подхода. И сделать то же самое уже в рамках стандартной и агентской разработки. Посадить разработчика, дать ему и агента, и чтобы он это запрограммировал. Не сам, а с помощью её агентов.
Потому что странно сейчас сравнивать срдовой подход с подходом, когда мы руками софт пишем. Наверное, это уже будет экономически неточно. Да, и, замерить. Во-первых, сколько человеческого времени ушло, и сколько мы потратили на создание такой среды. Ну и смасштабировать. Если мы поймём, что условно, мы если должны подключать эти платёжные системы там, раз в два месяца, каждый день, каждые два месяца новую, то это одна экономическая выгода.
Если мы подключаем её один раз и больше никогда не будем подключать, то это другая экономическая выгода. Это если конкретно мелкую среду рассматривать, только для таких адаптеров, таких интеграций. Я хочу, некий такой эксперимент провести, взять какой-то небольшой проект и там, возможно, в рамках своего преподавания в институте, там запустить такое, и как-то сравнить. Даёт ли выгоды либо нет, если даёт, то сколько, и так далее.
Некий такой пилот. Ну и, кстати говоря, вот в рамках, преподавания, я преподаю в ИТМО, у меня там есть свой собственный курс, который я веду. И плюс я веду немножко научную деятельность, выпускные квалификационные работы. У меня есть несколько проектных групп, магистрантов, которых я тоже загрузил вот проектные работы по средовому подходу. Они как раз вот сейчас пробуют тоже со своей стороны реализовать, создать некие там среды, некие, точнее, нене среды, а какие-то элементы среды, которые именно будут проверять, считать архитектурные метрики и так далее.
И если всё выгорит, мы прямо несколько этих проектных работ объединим, и получится, надеюсь, хорошая среда. Пробую и, получается, в рамках там коммерческих проектов, и в рамках вот там академических. Надеюсь, на всё хватит времени и сил.
Ответственность за результат
Владимир Гриненко. О'кей, будем ждать тогда апдейтов. Но давай пофантазируем, что вот всё получилось. И действительно работает, и доверять как будто бы там на большой череде обновлений можно, но в какой-то момент всё-таки задача выехала в прод, и уже в проде обнаружился баг. Вот кто? В новом мире, с средовым подходом будет ответственным. Потому что вот есть какой-то разработчик, который внутри среды инициировал, разработку новой фичи.
Есть команда, которая создавала эту среду и гарантировала вроде бы, что среда обеспечит все проверки, и есть какой-то та условный продукт, который изначально ставил вообще эту задачу. И у нас есть продакшн, и в нём всё поломано. Кто крайний?
Руслан Сафин. Мы сегодня поговорили про средовой подход в плане именно создания программного обеспечения. А в плане поддержки, в плане эксплуатации, тут, мне кажется, первое время ничего не изменится. Либо изменится, но это уже за рамками средового подхода, и тут всё плюс-минус стандартно. Да? Есть некие дежурные, которые разбирают инцидент, там, всё, наверное, как сейчас: L1, L2, L3, и на L3 мы делаем срочный хотфикс и при этом заводим какую-то карточку средовому инженеру, чтобы, как я уже сказал, чтобы он там разобрался в причинах и исправил на будущее.
Но хотфикс мы делаем руками с помощью ИИ-агентов, по старинке. С помощью ИИ-агентов по старинке. Интересно получилось.
Можно ли опровергнуть гипотезу
Владимир Гриненко. Нормально. Мне кажется, очень жизненно. А если к этой истории выдвигать те же требования, вот как выдвигает научный подход к любым гипотезам. Есть ли у тебя какоя-то, какая-то формулировка, которая бы позволила сказать, что мы опровергаем эту гипотезу, что вот есть какой-то способ убедиться, что нет, она ошибочная была? Или всё-таки это слишком абстрактная штука, чтобы к ней можно было с таким вопросом подойти?
Руслан Сафин. Если честно, если мы сейчас про научный подход будем говорить, можно ещё там на час засесть, потому что я несколько скептически отношусь к тому, что сейчас происходит. Не то чтобы скептически, а скорее, я считаю, что текущая парадигма познания, текущий научный подход, он несколько устарел. Потому что по факту он устарел вообще во всём. Если взять стандартную инженерию, то где-то с семидесятых годов прошлого века стандартная парадигма познания, она не работает.
Что я имею в виду? Сейчас мы до сих пор живём в парадигме, которая предложена была Бэконом и Ньютоном. Когда сначала мы разбираемся в том, как всё устроено, какой физический закон как оно там работает внутри, и потом на основе этого создаём некие механизмы, некое изобретение. - Уже там больше 50 лет. Инженеры не знают, как на самом деле и почему что-то работает. И при этом мы все пользуемся там микроволновками, ещё различными устройствами, которые до конца с точки зрения физики не описаны.
Если говорить про IT, то нейросети — это вообще вершина как сказать, вершина, которая показывает проблему. Мы, у нас нету какого-то, какой-то парадигмы познания, которая описывает то, как мы сейчас делаем изобретение, то, как мы двигаемся в научном прогрессе, в технологическом прогрессе. Потому что как работают нейросети, плюс-минус мы начали разбираться, как работает ChatGPT-3, только когда вышла ChatGPT-4.
И она начала объяснять, что там происходит на разных уровнях нейронов. Ни о каком научном подходе и там стандартной, классической парадигме познания речи быть не может. Насколько я знаю, я просто этим увлекаюсь, сейчас многие ищут новую парадигму. В России, допустим, развивается когнитивная парадигма. Что должно прийти на смену вот стандартной классической парадигме познания, да?
Как нам жить в этом мире, когда мы всё не можем понять. Берём это за аксиому, но это используем, это применяем и с этим как-то живём. Это отдельная большая тема, я этим интересуюсь, слежу за развитием этого всего, но как сказать, к финальному К финальной какой-то методологии, к научному новому подходу мы не пришли. Никто ещё в мире не пришёл, насколько я знаю. Так что, если там руководствоваться классическим подходом, научным по подходом.
Мне кажется, это немножко затормозит наш прогресс, и мы будем использовать то, что уже неприменимо к нашей текущей реальности, действительности.
Обучение и собеседования
Владимир Гриненко. Ну что ж, наверное, справедливо. А если говорить о том, что вот нужно менять подход вообще к тому, как мы смотрим на все эти вещи, и учитывая, что ты преподаёшь прямо сейчас начинающим инженерам то я бы тут, наверное, даже спросил не чему же их учить, а наоборот. Вот есть ли сейчас что-то, что благодаря внедрению кругом агентной разработки и нейронок в целом можно перестать учить?
Или там, если вот ты зовёшь кого-то к себе в компанию, есть ли что-то, что ты раньше бы на собеседованиях спрашивал, а теперь уже не будешь спрашивать, потому что это не имеет смысла.
Руслан Сафин. Мы, живём в очень интересное время, у нас есть мультипликатор наших способностей, в том числе нашей способности учиться. Если мы хотим учиться, знаем, какие вопросы задавать, у нас, практически в телефоне есть идеальный учитель, который знает всё на свете и который нам подскажет. Раньше так говорили про интернет, но из интернета всё-таки надо было знания самому как-то почерпнуть.
Нужно было там П прочитать, разобраться и так далее. А тут ты можешь прямо задавать вопросы, что тебе непонятно, и это абсолютно новый уровень обучения. Я тут недавно про один эксперимент прочитал, мне очень понравилось. В Европе взяли учеников, студентов, взяли тех, у кого плохие оценки и которые вообще очень сильно отстают, и дали им возможность просто напрямую общаться с преподавателями.
Не так, что ты там сидишь в рамках потока на 50—100 человек, и у тебя один преподаватель, а ты прямо можешь спрашивать конкретного преподавателя по разным предметам. И очень большой процент, не помню какой процент, вот отстающих студентов, они выбились в топ. Сразу это вот, возможность напрямую общаться с преподавателем. Не то что там преподавате, ты что-то спрашиваешь, а тебе преподаватель через неделю ответил.
А он прямо выделяет время, каждый преподаватель, и он тут же отвечает. И они очень, многие вырвались в топ. Проблема не в том, что они были какие-то неспособные, а что текущая система преподавания вот лекционная, им не подходила. А сейчас, по сути, у каждого из нас есть такой учитель, и те, кто раньше был, по каким-то причинам, если не мог приспособиться к системе образования, он будет, сейчас крайне успешен и не будет у него такого ограничения.
Так вот, это что касается, самого там изменения опять же подхода к образованию. Да, про вопрос, про собеседование. Конкретные знания, я уже давно считаю, что их не нужно спрашивать на собеседовании. Ну любой инженер, он там и даже без ИИ-агентов может загуглить и узнать что-то и там ответить на вопрос, если будет у него интернет. В нашей работе всегда есть интернет под рукой, и мне непонятно, почему там на собеседованиях нельзя было раньше интернетом пользоваться.
Теперь мне тоже непонятно, почему на собеседованиях нельзя и агентами пользоваться. Ты же в работе сможешь ими пользоваться? Почему на собеседовании нельзя? Поэтому, когда я веду собеседование, мне гораздо важнее понять ход мыслей, как человек мыслит. Что он будет спрашивать у нейросети. Это уже очень большой показатель. Более того, сейчас есть новый тренд, наверное, в HR, да?
Когда у всех есть корпоративная нейросеть, ты же можешь отслеживать, какие вопросы туда задаёт сотрудник. И по этим вопросам ты даже очень быстро можешь понять, по этим логам взаимодействия с нейросетью, как человек мыслит, о есть на каком уровне он мыслит. Не проблема, что он что-то спрашивает у нейросети на знания. Это вообще нормально, это абсолютно. А вообще, какие задачи он ей ставит, как он с ней взаимодействует.
Если проанализировать эти, на самом деле, логи общения человека с нейросетью, можно именно образ его мышления понять, уровень его мышления, насто насколько абстрактно и высоко он мыслит, либо он каким-то микроменеджментом занимается, либо вообще там, не знаю. Просто у него недостаточно там, каких-то черт характера для там его текущей деятельности. Это я не про программирование, это я вообще про любую деятельность, да?
Потому что в зависимости от черты характера мы можем более приспособленными быть к чему-то, либо нет. Это вот анализ такого взаимодействия с нейросетью даёт HR те знания, которые раньше никак было не собрать. Ну вот, возвращаясь на вопрос, про собеседование, я пытаюсь понять, как человек мыслит. В общении со студентами, особенно на практиках, я пытаюсь научить, наверное, образу мыслей — это неправильно, потому что у каждого он свой.
И, во-вторых, мой образ ничей нету правильного образа мыслей, да. Моя задача скорее показать, как я мыслю, как можно мыслить, какие есть варианты. И мы совместно разбираем, допустим, архитектуры. Студентов, магистрантов, и да, мы обсуждаем, почему лю человек пришёл к такому варианту. Над чем он размышлял. И вот кто-то защищается, кто-то рассказывает, а все остальные слушают. И таким образом растёт насмотренность.
Насмотренность не только конкретно в архитектуре, в архитектурных решениях, но и вот в способах и в образах мышления. Это, мне кажется, наиболее ценно в обучении, в преподавании. Ну и в преподавании тоже, потому что я, естественно, тоже на это всё смотрю, обучаюсь, у меня насмотренность растёт.
Пожелания слушателям
Владимир Гриненко. Ну что, мы вроде бы тему средового подхода раскрыли. Давай, может быть, сформулируем какое-то общее пожелание к зрителям, как им подключиться ко всей этой идеи и как можно вместе продвигаться к какому-то более эффективному способу строить софт.
Руслан Сафин. Мне кажется, главное сейчас, в наше время вообще смены всех парадигм, всех методологий иметь какое-то открытое мышление, открытый мозг. Не ограничиваться, стараться не думать стереотипами, там, теми подходами, тем нашим прежним опытом. Как сказать, смотреть вширь, смотреть на то, что есть, и не бояться пробовать что-то новое, пробовать самим, придумывать что-то новое и заявлять об этом в индустрию.
На мой взгляд, мы живём вообще в удивительное время, да. Я очень рад, что удалось его застичь. Да, Таое время изменений практически всего. Это сровни, как многие говорят, с изобретением электричества. Ну только если электричество, оно повлияло, наверное прежде всего на производство, если говорить про какой-то масштаб. У нас на производстве мы смогли делать гораздо больше, то сейчас есть именно доступ к некому интеллекту, и это может изменить масштаб деятельности каждого, даже каждого отдельного индивида, а не целой какой-то фабрики.
Что касается софта, мы точно входим в новую эру. И если бояться, что нас заменят, мне кажется, это как-то настраивает тот же образ мыслей на пессимистичный лад, и мы начинаем думать не в том ключе, смотреть не в ту сторону, как-то пытаться перестроить свою деятельность тоже не туда. Я считаю, что очень важны оптимизм и открытость мышления.
И благодаря этому мы все придём в светлое будущее и будем делать совершенно какие-то невообразимые для сегодняшних нас по масштабу открытия, задачи, проекты, системы и среды.
Владимир Гриненко. Класс. Спасибо большое, очень поддерживаю пожелания.
Руслан Сафин. Всем спасибо! Владимир, спасибо тебе, что позвал. Было очень интересно побеседовать.
Владимир Гриненко. Всем пока-пока.
Руслан Сафин. Всё, всем пока.
Смотреть и слушать