Андрей Крисанов

ИИ, агенты и инфраструктура

CI/CD в эпоху агентов

С интересом наблюдаю, как инженерные процессы и инструменты, к которым мы привыкли за десятки лет, переосмысливаются под ИИ-нативный подход. Например, классический CI/CD, построенный вокруг pull request-ов и человеческого темпа разработки, плохо подходит для мира, где код всё чаще пишут агенты.

До работы с агентами цикл разработки выглядел так: человек медленно пишет код → оформляет PR → CI прогоняет линтеры, тесты и сборку → другой человек ревьюит изменения → изменения попадают в основную ветку.

В такой парадигме долгое время работы CI-пайплайна часто было ожидаемым и терпимым, потому что самая большая задержка всё равно была на стороне команды: разработчик писал код часами или днями, ревью тоже ждали часами или днями, PR жил долго.

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

Но CI/CD вряд ли не исчезает. Скорее он перестанет быть контуром вокруг которого происходит работа с изменениями и превратится в низкоуровневый слой для быстрой проверки изменений внутри агентного цикла. Почему так?

CI/CD в текущем виде был спроектирован для мира, где человек — главный агент.

Человек держит в голове некое намерение: например, «хочу добавить кнопку оформления заказа». Потом проходит цикл: намерение → код → pull request → CI → код-ревью → merge. На каждом этапе может быть откат назад:

  • PR не по принятому формату → назад к коду
  • тесты упали → назад к коду
  • ревьюер попросил изменить API → назад к коду
  • merge queue показывает, что ветка отстаёт от main → назад к коду

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

Когда код пишет не человек, а агент, меняются масштабы:

  • много агентов могут параллельно выполнять работу
  • появляется много короткоживущих веток
  • растёт количество PR
  • частые исправления становятся нормальной частью агентного цикла

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

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

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

Цель + план
      ↓
Агентный цикл:
  генерация кода
  внутренняя валидация: сборка, тесты, линтеры
  внешняя валидация: человек или специализированные агенты
  исправления по обратной связи
      ↓
Merge Queue
      ↓
Репозиторий

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

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

Человеку уже не нужно будет читать каждый diff, как это было раньше. Он будет смотреть на более высокий уровень:

  • была такая цель
  • вот что получилось
  • вот summary изменений
  • вот результат security-проверок
  • вот риски
  • вот демонстрация работы

И только после этого принимать решение: approve, reject или «нужны правки».

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

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

В итоге мы получим не просто CI job после git push, а что-то ближе к continuous compute: вычислительную среду, которая постоянно работает вокруг intent-а, кода, валидации и изменений-кандидатов на слияние с основной веткой.

Будущее MCP

Посмотрел доклад David Soria Parra из Anthropic про будущее MCP.

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

Основые тезисы из доклада Дэвида с моими дополнениями 👇🏻

MCP — не серебряная пуля, а важный компонент агентной системы

Лучшие агенты будут использовать не только MCP, но и:

  • CLI
  • skills
  • браузер и другие приложения
  • API сервисов
  • платформенные решения

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

REST API → MCP 1:1 — плохая идея

Не стоит брать REST API и превращать его в MCP-сервер просто обернув суще API-методы.

REST API обычно спроектирован для разработчиков и CRUD-операций:

GET /users
POST /orders
PATCH /documents/:id

А агенту чаще нужен не набор низкоуровневых методов, а осмысленное действие:

  • создай отчёт за период
  • найди договор и проверь риски
  • подготовь черновик ответа клиенту
  • сравнить версии документа

Хороший MCP-интерфейс должен быть нативным для агента, а не оберткой поверх когда-то разработанного API. Это важный сдвиг в мышлении при проектировании агентных систем.

Информация о тулах должна быть доступна модели по требованию

Одна из проблем, с которой мы сейчас сталкиваемся на практике — многие интеграции через MCP выгружают агенту огромный список tools, который затем утекает в контекстное окно модели. Как следствие:

  • модель хуже выбирает нужный инструмент
  • растёт стоимость запроса
  • растёт latency ответа
  • повышается риск неправильного tool call
  • контекст забивается описаниями инструментов вместо полезной информации

Anthropic предлагает реализовывать progressive discovery: агент должен постепенно получать нужные инструменты, а не весь список доступных tools сразу.

Для разработчика это означает, что нам нужно думать не только о том, какие tools предоставлять модели, но и как модель будет их находить.

Skills и MCP не конкуренты

Skills хорошо подходят для локальных, процедурных, CLI-based сценариев. Например, «возьми ffmpeg, обработай видео, положи результат сюда». MCP лучше подходит там, где нужны:

  • авторизация
  • RBAC
  • аудит действий и observability
  • управление доступом к инструментам
  • стабильный контракт между агентом и внешней системой

Общая рекомендация сейчас: используйте самый простой механизм, который решает вашу задачу. MCP-сервер не нужен для каждого shell-скрипта. Но если инструмент живёт в enterprise-среде и работает к чувствительными данными, то Skills — менее надёжное решение.

Enterprise-агентам нужен gateway

Для компаний главный вывод такой: нельзя позволять каждой команде поднимать свой зоопарк MCP-серверов и гейтвеев.

Нужен общий слой, который решает следующие задачи:

  • единая точка подключения инструментов
  • авторизация и политики доступа
  • аудит вызова tools
  • лимиты
  • логирование, observability
  • контроль того, какие агенты к чему имеют доступ
  • контроль жизненного цикла инструментов

Иначе через год разработки получится не AI-платформа, а распределённая коллекция небезопасных интеграций, которые никто не понимает и не контролирует.

В докладе это формулируется как движение к общему connectivity/gateway-слою, т. е. не каждый агент сам знает обо всех системах, а платформа даёт ему управляемый доступ.

Идентичность агентов

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

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

Возникают вопросы:

  • кто именно вызвал tool
  • от чьего имени
  • с какими правами
  • можно ли агенту продолжить задачу без подтверждения пользователя
  • как отозвать доступ
  • как показать аудитору, что произошло

Это отдельный пласт инженерной работы. И он пока решён хуже, чем хотелось бы.

TLDR;

MCP — это не просто новый стандарт для тулов. Это сигнал, что разработчикам придётся учиться проектировать интерфейсы для агентов, а не только API для людей и frontend-приложений.

Практические советы:

  • Не делайте глупую 1-1 обертку REST-to-MCP. Сначала подумайте, какое действие реально должен выполнить агент.
  • Проектируйте тулы как атомарные действия, которые можно соединять в более крупную задачу. Не createUser, updateUser, deleteUser, а «подготовить пользователя к онбордингу», «проверить доступы к X», «собрать контекст по клиенту».
  • Ограничивайте набор тулов для задачи. Чем больше инструментов вы добавите в контекст, тем хуже может работать агент (а точнее модель).
  • Думайте о discovery инструментов по запросу. Агенту не обязательно знать обо всех тулах сразу. Лучше сделать каталог тулов и progressive discovery.
  • Сразу закладывайте аудит и работу с правами доступа. Особенно если инструмент может читать документы или менять данные.
  • Используйте CLI там, где этого достаточно. Не стоит реализовывать MCP ради MCP.
  • Для enterprise-сценариев нужен gateway. Без него MCP быстро превращается в shadow IT для агентов.
The Future of MCP — David Soria Parra, Anthropic

Сколько на самом деле стоит GenAI в продакшене

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

Стоимость GenAI-системы — это не только сколько стоит вызвать модель. Это инфраструктура, эксплуатация, безопасность, наблюдаемость, разработка, интеграции, поддержка пользователей и постоянные изменения вокруг моделей. Именно поэтому «мы поднимем open-source модель сами, будет дешевле» часто оказывается правдой только на первом слайде презентации.

Из чего складывается стоимость GenAI в продакшене

Типовая GenAI-система состоит не из одной модели. Даже если бизнес-задача звучит просто, например, сделать Q&A чат-бота по документам, внутри быстро появляются:

  • backend-сервис (API)
  • модель или несколько моделей
  • RAG: индексация документов, эмбеддинги, векторный поиск
  • хранилище документов
  • авторизация и права доступа
  • модерация и guardrails
  • трассировка запросов
  • мониторинг качества
  • логирование ошибок
  • рейт-лимиты, очереди и ретраи
  • CI/CD
  • регламент обновления моделей
  • поддержка пользователей и команд, которые интегрируются с этим сервисом

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

Цена за токен — заметный, но не единственный расход

Если использовать Yandex Cloud AI Studio, стоимость зависит от режима работы модели и количества токенов: входных, исходящих, кешированных и токенов инструментов. Это уже важная деталь: один и тот же пользовательский сценарий может стоить по-разному в зависимости от длины промпта, длины ответа, истории диалога и использования tools.

Например, в синхронном режиме YandexGPT Pro 5.1 стоит 0,8 ₽ за 1000 входящих токенов и 0,8 ₽ за 1000 исходящих токенов с НДС. YandexGPT Lite стоит 0,2 ₽ за 1000 входящих и 0,2 ₽ за 1000 исходящих токенов. DeepSeek V3.2 в AI Studio стоит 0,5 ₽ за 1000 входящих токенов и 0,8 ₽ за 1000 исходящих токенов.

Допустим, у нас есть внутренний ассистент, который обрабатывает 1 млн запросов в месяц. Средний запрос:

  • 1000 входящих токенов
  • 500 исходящих токенов

Тогда примерная стоимость генерации:

Модель Расчёт на 1 запрос 1 млн запросов в месяц
YandexGPT Lite 0,2 ₽ + 0,1 ₽ 300 000 ₽
YandexGPT Pro 5.1 0,8 ₽ + 0,4 ₽ 1 200 000 ₽
DeepSeek V3.2 0,5 ₽ + 0,4 ₽ 900 000 ₽

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

Покупка GPU vs оплата за токены

Другой популярный подход — поднять open-source модель самостоятельно на своей инфраструктуре. Например, через vLLM, TGI или другой serving-стек.

В Yandex DataSphere конфигурация g2.8 с 8 GPU A100 стоит 4 401,83808 ₽ в час. При расчёте 720 часов в месяц это примерно:

4 401,84 ₽ × 720 ≈ 3 169 323 ₽ / месяц

Конфигурация g2.1 с 1 GPU A100 стоит 550,22976 ₽ в час, а g1.1 с 1 GPU V100 — 341,52192 ₽ в час. Цены DataSphere для региона Россия указаны с НДС.

На первый взгляд, 8×A100 за ~3,17 млн ₽/месяц может выглядеть конкурентно, если у вас большой объём трафика. Но это только compute. Дальше нужно добавить:

  • Kubernetes или другой runtime
  • хранилище для моделей и образов (container registry)
  • observability стек (наблюдаемость)
  • сетевую инфраструктуру
  • инженерную команду

а также процессы вокруг:

  • обновления моделей
  • тестирования качества
  • безопасности
  • работу с деградациями и инцидентами

DataSphere отдельно тарифицирует хранение моделей, Docker-образов, дисков, датасетов и других артефактов; например, хранение модели внутри DataSphere сверх бесплатных лимитов стоит 13,08 ₽ за 1 ГБ в месяц.

То есть self-hosting может быть дешевле на большом масштабе. Но он редко бывает дешевле сам по себе. Он становится выгодным, когда у компании уже есть сильная инфраструктурная команда, понятный объём нагрузки и реальная потребность контролировать serving, latency, безопасность и модельный стек.

Главный скрытый расход — ФОТ

В России стоимость инженерной команды ниже, чем в США, но она всё равно быстро становится одной из основных категорий расходов. По данным Dream Job, средняя зарплата ML Engineer в России в 2026 году — 185 000 ₽ на руки, типичный диапазон — 140 000—230 000 ₽, а в Москве среднее значение указано как 260 000 ₽. Другой обзор по рынку ML-инженеров указывает ориентиры по грейдам: Middle — около 160 000—200 000 ₽, Senior — 280 000—350 000 ₽, Lead — 360 000—450 000 ₽ в зависимости от региона и формата работы.

Но для продакшен GenAI вам обычно нужен не один ML Engineer. Минимальный состав может выглядеть так:

Роль Зачем нужна
Backend Engineer API, бизнес-логика, интеграции
ML / LLM Engineer выбор моделей, промпты, evals, качество
Platform / DevOps Engineer Kubernetes, GPU, CI/CD, observability
Security / InfoSec доступы, данные, аудит, compliance
Product / Analyst сценарии, метрики, приоритизация

Даже маленькая команда из 2—3 сильных инженеров может стоить компании заметно больше, чем API-вызовы модели. Особенно если считать не только зарплату на руки, а полную стоимость сотрудника: налоги, оборудование, менеджмент, найм, отпуска, простои, коммуникации и стоимость ошибок.

Именно здесь часто ломается наивная математика: API стоит 1 млн ₽ в месяц, а self-hosting на GPU — 3 млн ₽. Значит API дешевле.

Или наоборот: GPU стоит 3 млн ₽ в месяц, а API при нашем объёме стоит 5 млн ₽. Значит self-hosting дешевле.

Обе оценки неполные. Нужно считать людей, эксплуатацию, риски и качество.

Доступ к LLM через API vs self-hosting

Упрощённо выбор выглядит так.

Доступ к LLM через API

Выгоднее если вы только запускаете продукт, нагрузка непредсказуема, команда маленькая, а главная задача — быстро проверить гипотезу. В этом случае YandexGPT, DeepSeek или другие модели через API позволяют не строить всю инфраструктуру с нуля.

Плюсы:

  • быстрый старт
  • не нужно управлять GPU
  • проще масштабироваться на раннем этапе
  • меньше эксплуатационной нагрузки
  • проще считать стоимость на уровне токенов

Минусы:

  • зависимость от провайдера
  • ограничения по моделям и настройкам
  • меньше контроля над latency (временем отклика)
  • сложнее оптимизировать serving под свой сценарии и тип нагрузки
  • возможные ограничения по данным и комплаенсу

Self-hosting моделей

Выгоднее если у вас большой и стабильный объём запросов, есть инфраструктурная команда, нужны строгие требования по данным, есть желание контролировать модели, serving-стек, batching, маршрутизацию и стоимость на большом масштабе.

Плюсы:

  • больше контроля
  • можно оптимизировать serving
  • можно выбирать open-source модели
  • можно строить собственный роутинг и механизмы кэширования
  • потенциально ниже стоимость за токен на большом объёме

Минусы:

  • высокая сложность
  • нужен опыт с GPU-инфраструктурой
  • нужны SRE-практики
  • нужно самим решать инциденты
  • нужно самим обновлять модели
  • нужно самим строить evals и release gates

Скрытые расходы, о которых забывают

Наблюдаемость

Для обычного backend-сервиса достаточно latency, error rate, throughput и логов. Для LLM-системы этого мало.

Нужно понимать:

  • сколько токенов потребляется
  • какие промпты дают плохие ответы
  • где растёт latency
  • где модель галлюцинирует
  • какие пользователи повторяют запросы
  • какие инструменты вызываются
  • какие документы попадают в контекст
  • как меняется качество после обновления модели

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

Обновление моделей

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

Каждое обновление требует:

  • регрессионного тестования
  • сравнения качества
  • проверки промптов
  • проверки latency
  • проверки стоимости
  • коммуникации с пользователями
  • rollback-плана

Если этого нет, можно обновить модель и сломать upstream-команды.

Безопасность

В корпоративном контексте вопрос не только в том, где дешевле токен.

Нужно отвечать на вопросы:

  • какие данные уходят в модель
  • логируются ли запросы
  • где хранятся трейсы запросов
  • можно ли отправлять персональные данные
  • как работает маскирование PII и других данных
  • кто имеет доступ к истории запросов
  • можно ли использовать внешние tools
  • как аудитить действия агента

Это не бесплатная часть системы. Её кто-то должен проектировать, внедрять и поддерживать.

Качество

Стоимость плохого ответа может быть выше стоимости токенов.

Например, если модель помогает бухгалтерии, юристам, поддержке или инженерам, ошибка может привести к:

  • потере времени
  • неправильному решению
  • ручной перепроверке
  • недоверию пользователей
  • отказу от продукта
  • инциденту безопасности

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

Как посчитать полную стоимость GenAI-системы

Хорошая формула выглядит не так:

TCO = цена токенов

где TCO — это Total Cost of Ownership, т. е. полная стоимость владения.

А примерно так:

TCO =
  стоимость inference
+ стоимость инфраструктуры
+ стоимость хранения
+ стоимость сети
+ стоимость разработки
+ стоимость эксплуатации
+ стоимость observability
+ стоимость безопасности
+ стоимость обновления моделей
+ стоимость ошибок

Для managed API основная переменная часть — токены. Для self-hosting — GPU, инфраструктура и команда.

Практический подход:

  1. Посчитать ожидаемый объём запросов.
  2. Разделить входные и исходящие токены.
  3. Посчитать стоимость для 2—3 моделей.
  4. Добавить RAG: embeddings, хранилища, поиск.
  5. Добавить observability и логи.
  6. Оценить стоимость команды.
  7. Оценить стоимость поддержки и инцидентов.
  8. Сравнить API и self-hosting не на демо, а на горизонте 6—12 месяцев.

Пример: внутренний AI-ассистент

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

Параметры:

  • 1 000 активных пользователей
  • 30 запросов на пользователя в месяц
  • 30 000 запросов в месяц
  • 1 500 входящих токенов
  • 700 исходящих токенов

Для YandexGPT Pro 5.1:

Вход: 1500 / 1000 × 0,8 ₽ = 1,2 ₽
Выход: 700 / 1000 × 0,8 ₽ = 0,56 ₽
Итого: 1,76 ₽ за запрос

30 000 × 1,76 ₽ = 52 800 ₽ / месяц

Для YandexGPT Lite:

Вход: 1500 / 1000 × 0,2 ₽ = 0,3 ₽
Выход: 700 / 1000 × 0,2 ₽ = 0,14 ₽
Итого: 0,44 ₽ за запрос

30 000 × 0,44 ₽ = 13 200 ₽ / месяц

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

Но если это уже не 30 000, а 3—10 млн запросов в месяц, математика меняется. Тогда имеет смысл отдельно смотреть на кэширование, роутинг запросов, batch-режимы, более дешёвые модели для простых задач и self-hosting.

Вывод

Главная ошибка при оценке GenAI систем — сравнивать только цену токена или часа за аренду GPU.

Для прототипа это нормально. Для продакшена — нет.

Managed API может быть дороже на единицу inference, но дешевле по TCO (полной стоимости владения), если экономит месяцы разработки и эксплуатации. Self-hosted open-source модель может быть дешевле на большом объёме, но только если у вас есть команда, инфраструктура и зрелые процессы.

Правильный вопрос звучит не так:

Какая модель дешевле?

А так:

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

И почти всегда ответ зависит не от одной цены в прайсе, а от масштаба, команды и зрелости компании.

Go как язык программирования в эпоху агентов

На дворе 2026 год, и любые рассуждения о разработке с AI-агентами рискуют устареть быстрее, чем мы допишем README.md в нашем репозитории. Тем не менее некоторые вещи уже начинают выглядеть не как временный шум, а как новые инженерные практики.

Одна из таких вещей — изменение отношения к языкам программирования.

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

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

И в таком цикле Go выглядит неожиданно хорошо.

Так ли критичны недостатки Go

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

Примерно так:

data, err := os.ReadFile(path)
if err != nil {
    return fmt.Errorf("read config %q: %w", path, err)
}

Никакой поэзии — зато всё понятно.

Такая многословность иногда раздражает. Писать однотипную обработку ошибок руками — удовольствие так себе. Генерировать обвязку, тесты, HTTP-ручки, конфигурацию, простые клиенты к API — тоже не самая вдохновляющая работа.

Но AI-агентам для написания кода всё равно. Они не страдают от кучи похожего кода, не закатывают глаза на очередной if err != nil. Они просто генерируют код, а потом получают от компилятора и тестов обратную связь.

В этот момент недостатки Go перестают быть такими уж серьёзными. А старые достоинства — простота, явность, единообразие — становятся гораздо важнее.

AI любит предсказуемость

Чем больше в языке и экосистеме вариантов сделать одно и то же, тем выше шанс, что модель выберет не тот вариант.

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

Для опытного разработчика это пространство выбора. Для модели — пространство для галлюцинаций.

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

Модель лучше работает там, где меньше случайности. Go как раз про это.

Хороший агентный цикл важнее синтаксиса

В разработке c AI-ассистентами и агентами не надо верить, что модель сразу напишет идеальный код — это завышенное ожидание. Скорее всего, не напишет. Или напишет почти правильно, что иногда даже хуже.

Нормальный процесс выглядит иначе: план → генерация кода → сборка → тесты → исправления → ревью.

И чем проще этот цикл, тем лучше:

gofmt -w .
go test ./...
go vet ./...
golangci-lint run

Ошибки компилятора обычно конкретные. Тесты запускаются просто. Форматирование единое. Линтеры можно встроить в CI. Сборка проекта не требует сложного окружения и скриптов. Во многих случаях на выходе получается один бинарник, который легко положить в контейнер и отправить в продакшен.

Такие скучные вещи делают AI-разработку безопаснее. Промптами можно объяснить агенту многое, но не всё. А вот компилятор, тесты, линтеры, контракты API и CI-проверки не интерпретируют задачу творчески, как это могут делать модели. Они просто говорят: вот здесь сломано, чини.

Такие инструменты гораздо надёжнее, чем надеяться на длинный промпт в духе «пожалуйста, пиши хороший код».

Go как язык для разработки с кодинговыми агентами

AI не отменяет инженерную дисциплину. Скорее наоборот: он делает её важнее.

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

В этом смысле Go интересен не сам по себе, а как пример правильной экосистемы для новой реальности:

  • меньше магии, больше явности
  • быстрый feedback loop
  • хорошие инструменты из коробки
  • простая сборка под любую архитектуру и ОС

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

И, возможно, именно поэтому Go сейчас выглядит сильнее, чем несколько лет назад. Не потому что он изменился, а потому что изменился контекст вокруг него.

Установка DCGM Exporter в локальный Kubernetes-кластер с NVIDIA GPU

В предыдущей заметке я рассказывал как развернуть локальный кластер Kubernetes с доступом к GPU внутри WSL2 окружения. Для того, чтобы собирать детальные метрики с видеокарты, nvidia-smi не достаточно, т. к. GPU-Util показывает только активность в рамках короткого sampling-окна. Для анализа того, что происходит с GPU при обработке задач, нужен DCGM. dcgm-exporter — это утилита NVIDIA для сбора GPU-метрик через DCGM, которая отдает их через HTTP-метод /metrics для Prometheus и похожих систем мониторинга.

При попытке установить dcgm-exporter в k3s кластер Helm chart по умолчанию создает ServiceMonitor. Но если в кластере не установлен Prometheus оператор, процесс завершится с ошибкой:

no matches for kind "ServiceMonitor" in version "monitoring.coreos.com/v1"
ensure CRDs are installed first

Это ожидаемое поведение. В dcgm-exporter chart по умолчанию serviceMonitor.enabled: true, а ServiceMonitor относится к CRD из экосистемы Prometheus Operator. В том же чарте runtimeClassName — пустой.

Проверяем, что Kubernetes все еще видит GPU:

kubectl get nodes -o json | jq '.items[].status.allocatable'

На моей системе результат такой:

{
  "cpu": "20",
  "ephemeral-storage": "1027046117185",
  "hugepages-1Gi": "0",
  "hugepages-2Mi": "0",
  "memory": "16233644Ki",
  "nvidia.com/gpu": "1",
  "pods": "110"
}

Далее добавляем репозиторий:

helm repo add gpu-helm-charts https://nvidia.github.io/dcgm-exporter/helm-charts
helm repo update

Отключаем создание ServiceMonitor и указываем Nvidia runtime class:

helm install dcgm-exporter gpu-helm-charts/dcgm-exporter \
  --set serviceMonitor.enabled=false \
  --set runtimeClassName=nvidia

Проверяем, что pod с экспортером поднялся:

kubectl get pods -l app.kubernetes.io/name=dcgm-exporter -o wide
kubectl logs -l app.kubernetes.io/name=dcgm-exporter --tail=50

Успешный запуск выглядит примерно так:

Starting dcgm-exporter
Attempting to initialize DCGM.
Initialized DCGM Fields module.
Attempting to initialize NVML library.
NVML provider successfully initialized for Kubernetes MIG support
DCGM successfully initialized!
Successfully queried DCGM profiling metric groups
HTTP server started - ready to serve metrics
Listening on [::]:9400

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

  • DCGM инициализировался
  • NVML инициализировался
  • exporter увидел GPU
  • HTTP endpoint с метриками уже работает

Если chart создал сервис, его можно посмотреть так:

kubectl get svc

Дальше пробрасываем порт:

kubectl port-forward svc/dcgm-exporter 9400:9400

И проверяем:

curl http://127.0.0.1:9400/metrics | head -50
curl http://127.0.0.1:9400/health

Если все ок, /health вернет успешный ответ, а /metrics начнет отдавать метрики вида DCGM_FI_*.

Ранее Ctrl + ↓