Процесс разработки в tiny team: роли людей, роли ИИ-агентов, их взаимодействие

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

Команда из трёх человек с ИИ-агентами — это не «трое плюс игрушечный чат-бот», и не «безлюдная фабрика». Правильная рамка вопроса: какие роли в процессе разработки остаются за людьми, какие отдаются агентам, и в каких точках они соприкасаются. Мировая практика за последние два года дала по этой теме достаточно материала — от инженерных блогов Anthropic и OpenAI до фреймворков с тысячами цитирований, — чтобы описать рабочую схему, а не гадать. В этой статье такая схема: уровни автоматизации, роли людей, роли агентов и пошаговый цикл задачи.

Отправная точка — статья Anthropic «Building effective agents»: начинать нужно с самого простого решения, которое решает задачу, и усложнять только когда простого перестаёт хватать. Эта же логика применима к ролям: не «выдадим каждому агенту по роли», а «проверим, где без роли вообще можно обойтись».

Три уровня участия агентов

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

Workflows (сценарии). LLM и инструменты вызываются по заранее описанному пути: «получил задачу → сгенерировал черновик → прогнал проверку → отдал человеку». Ход процесса определяет код, а модель делает шаги. Это предсказуемо, дёшево в отладке и покрывает большинство потребностей маленькой команды: черновики текстов и тестов, проверка кода, сборка дайджестов.

Agents (автономные исполнители). Модель сама решает, каким будет следующий шаг, какие инструменты вызвать и когда закончить. Нужно для открытых задач: «разберись, почему тесты падают в CI, и почини». Дороже по токенам, менее предсказуемо — и незаменимо там, где путь решения неизвестен заранее.

Мультиагентные системы. Несколько агентов с разделёнными ролями под оркестратором. Здесь проходит главная живая дискуссия практики 2025 года: Anthropic сообщает, что их мультиагентная исследовательская система обошла одиночного агента на 90,2% во внутреннем бенчмарке (ценой примерно 15-кратного расхода токенов), а Cognition, авторы Devin, предостерегают: разделение на субагентов фрагментирует контекст, и «дочерние» агенты принимают решения вслепую. Синтез этих позиций от Харрисона Чейса из LangChain практичен: параллелить имеет смысл только действительно независимые подзадачи, а контекст между агентами нужно передавать явно и полно.

Вывод для tiny team: базовый режим — workflows с человеком в ключевых точках; автономные агенты — точечно, для открытых задач; мультиагентность — только когда одна роль физически не справляется с объёмом независимо параллелимых проверок.

Что остаётся за людьми

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

Владелец продукта. Решение «что делаем и что НЕ делаем» — всегда человеческое. Агент может принести десять тем, посчитать спрос и написать черновики, но ценностный выбор — за тем, кто отвечает за продукт перед пользователем и бизнесом. В tiny team эта роль не делегируется никому.

Инженер-архитектор. Структурные решения — выбор стека, границы модулей, что технический долг чиним, а что переживаем. Агент напишет код быстро и неправильно, если архитектуру ему не задать; хорошо заданную архитектуру он реализует быстро и правильно. Правильный вопрос к агенту — не «спроекти», а «реализуй так-то и объедини принципы такие-то».

Приёмщик. Тот, кто говорит «принято» и ставит подпись под результатом — кодом, текстом, решением. Это гейт, который нельзя убирать: репутационные и финансовые последствия решения всегда человеческие. У Anthropic это формулируется как правило «агент предлагает — человек утверждает» для всего, что имеет последствия за пределами песочницы.

Оператор агентов. Новая роль, о которой стоит сказать отдельно: тот, кто пишет и прокачивает инструкции агентов, настраивает границы их прав, читает журналы и решает, где автоматизация деградировала. В маленькой команде это шляпа, которую носит по очереди каждый — как роль дежурного по процессу. Навык «описать задачу так, чтобы её выполнила машина, и проверить результат» — самый дефицитный навык 2026 года; в tiny team его выращивают все.

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

Типовые роли агентов

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

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

Исполнитель (генератор). Пишет черновик по спецификации: код по задаче, текст по брифу, тесты по сценарию. Ключевое слово — «черновик»: выход исполнителя всегда проходит чужую проверку, никогда не идёт сразу в прод.

Критик (проверяющий). Читает результат с задачей найти ошибки — код-ревью, фактчекинг, редактура, тесты на чужой код. Принцип, который нельзя нарушать: генератор и критик — разные агенты с разными инструкциями. Самопроверка модели — реальный и полезный приём (один из классических «агентных паттернов» по Эндрю Ыну, наряду с использованием инструментов и планированием), но как единственный контроль она не работает: у модели есть системная слепота к собственным ошибкам, и другой экземпляр с независимой инструкцией видит то, что генератор пропустил.

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

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

Как они взаимодействуют: артефакты, гейты, границы

Взаимодействие людей и агентов в отлаженном процессе устроено не как «переписка в чате», а как конвейер с контрактами. Три элемента делают его надёжным.

Артефакт как контракт. Каждый шаг производит проверяемый артефакт: спецификацию, черновик, вердикт проверки, журнал изменений. Артефакты живут в репозитории — тогда у каждого результата есть история, а любой спор «кто это сломал» решается git log. Формат вердиктов проверяющих агентов делают машинно-читаемым (структурированный JSON со статусом и списком проблем) — следующий шаг конвейера парсит его без «понимания» свободного текста.

Гейты с человеком. Точки, где конвейер останавливается и человек принимает решение: утверждение спецификации до генерации, ревью результата перед слиянием, approvals внешних действий. Каждый гейт стоит времени, поэтому их ставят ровно столько, сколько стоит цена пропущенной ошибки. Мировая практика тут устойчива: чем ниже цена ошибки и выше проверяемость результата, тем позже можно ставить человека; необратимые и внешние действия — всегда через человека.

Границы автономии. Для каждого агента явно описано, что он делает сам, а на что у него права только предлагать: агент-исполнитель пишет код в ветку, но не пушит в main; публикатор готовит релиз, но релиз утверждает человек. Проектирование этих границ — половина работы по настройке, и об этом — отдельная статья: как настроить агентов для tiny team.

Цикл задачи от гипотезы до продакшена

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

  1. Гипотеза. Человек формулирует: что меняем, зачем, как проверим успех. Выход — карточка-спецификация на полстраницы. (человек)
  2. Сбор контекста. Исследователь собирает материалы: как устроен текущий код, что писали другие, какие есть ограничения. Выход — выжимка со ссылками, приложенная к карточке. (агент)
  3. Спецификация. Исполнитель превращает гипотезу и контекст в техническую спецификацию: что именно меняется, какие файлы, какие тесты. Выход — спецификация. (агент)
  4. Утверждение спецификации. Гейт: человек читает и правит. Пять минут внимания здесь экономят часы переделок — это самая дешёвая точка контроля в цикле. (человек)
  5. Генерация. Исполнитель пишет код и тесты по утверждённой спецификации. Выход — ветка с изменениями. (агент)
  6. Критика. Критик ревьюит код и гоняет проверки: тесты, линтеры, безопасность зависимостей, соответствие спецификации. Выход — вердикт: принято / список правок. При правках — возврат на шаг 5, с ограничением на число итераций. (агент)
  7. Ревью человека. Гейт: инженер смотрит дифф. Благодаря шагу 6 это уже финальная полировка, а не вычитка черновика: человек тратит минуты, а не часы. (человек)
  8. Слияние и выкатка. Сборка, деплой, дымовой тест. Выход — изменение у пользователей. (автоматика)
  9. Наблюдение. Мониторинг и метрики: сработало ли то, ради чего затевалось. Наблюдатель собирает аномалии; несработавшая гипотеза — не провал, а знание, которое возвращается в бэклог. (агент + человек на реакции)

Обратите внимание на пропорцию: люди появляются на трёх шагах из девяти, но именно на тех, где принимаются решения — что делать, как делать и достаточно ли хорошо сделано. Всё остальное — работа по критерию, и её выполняют агенты. Это и есть практический ответ на вопрос «заменит ли ИИ разработчиков в tiny team»: он забирает исполнение и проверку исполнения, а решения, ответственность и вкус оставляет людям — и умножает их пропускную способность.

Ошибки, которые совершают чаще всего

  • Агент-генератор сам себя проверяет. «Напиши и проверь» в одной инструкции дешевле по токенам и хуже по качеству: слепота к собственным ошибкам системна. Разделяйте роли генерации и критики — даже если это одна и та же модель с разными инструкциями.
  • Автономность раньше предсказуемости. Команда сразу строит «агентную команду» вместо workflow-цепочки, получает недетерминированный процесс и не может отладить. Мировой консенсус: сначала сценарии, автономия — точечно.
  • Человек выведен из петли. Гейты убрали ради скорости; ошибка агента уехала к пользователям. Восстановление гейтов после инцидента всегда дороже их поддержания.
  • Контекст не передаётся между шагами. Проверяющий агент видит только дифф без спецификации — и проверяет не то. Каждому агенту на каждом шаге нужен полный контекст решения: это ровно тот вывод, который Cognition сделал из своих неудач с мультиагентами.
  • Роль без владельца. «Наблюдатель? он сам посмотрит» — не посмотрит. Если у роли агента нет человека, который за неё отвечает, роли нет — есть самообман.

Резюме: процесс разработки с агентами — это конвейер с контрактами-артефактами, независимой критикой и гейтами человека в точках решений. Люди держат четыре функции: ценность, архитектуру, приёмку и оперирование агентами. Агенты берут исполнение и проверку — с базовым режимом «workflow прежде автономии». Такой процесс не требует ни больших команд, ни больших бюджетов — он требует аккуратности в ролях и границах, и именно это делает его естественной формой организации для tiny team.