Главная проблема AI-разработки не в коде. Главная проблема в контексте

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

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

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

Я начал с простой идеи: вся работа агентов должна попадать в единый бек, за основу я взял проект Multica по сути это веб интерфейс управления агентами и задачами, но без контекстного слоя, его я и добавил

Неважно, где именно агент запускался: Codex, Claude Code, Cursor, другой CLI или внутренняя обертка. Важно, чтобы результат не исчезал в чате.

Нужен слой, где сохраняется сама работа:

На базовом уровне это дает наблюдаемость.

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

Это уже полезно.

Потому что иначе AI-разработка часто выглядит как черный ящик:

"Я что-то попросил, оно что-то сделало, вроде работает."

Но мне этого было мало.

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

Поэтому основная работа ушла в AI Context слой.

Я не хотел делать еще одну папку с инструкциями в стиле:

"Ты опытный разработчик. Пиши чистый код. Следуй best practices."

Такие инструкции почти бесполезны.

Мне нужен был слой, который хранит нормальный рабочий контекст проекта.

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

И главное: этот контекст должен жить отдельно от конкретного чата.

У проекта должна быть память.

Не в философском смысле, а в самом бытовом инженерном:

"Перед тем как трогать этот сервис, прочитай вот это. Здесь уже были проблемы. Вот текущее состояние. Вот чего мы сейчас добиваемся."

README обычно отвечает на вопрос: "Как запустить проект?"

Иногда еще: "Что это вообще такое?"

Но агенту для нормальной работы нужно больше.

Ему нужно понимать не только статичную документацию, но и текущую рабочую ситуацию.

Например:

Человек это обычно держит в голове.

Агент нет.

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

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

Разница ощущается очень быстро.

Обычный сценарий:

"Вот задача, вот репозиторий, попробуй разобраться."

Сценарий с контекстом:

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

Это не превращает агента в идеального разработчика.

Он все еще может ошибаться. Может не понять задачу. Может предложить странное решение. Может потратить токены впустую.

Но он уже не стартует с нуля.

Он не заходит в пустой репозиторий. Он заходит в рабочую среду.

Для меня это принципиальный сдвиг.

Потому что одно дело, когда AI просто генерит куски кода.

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

Сейчас инструменты развиваются очень быстро.

Сегодня тебе удобнее Codex. Завтра Claude Code лучше справился с большим рефакторингом. Послезавтра Cursor удобнее для точечных правок. Потом появится еще один агент, который делает какую-то часть лучше остальных.

Я не хочу завязывать процесс разработки на один конкретный инструмент.

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

Агент может быть разный.

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

Иначе получается зоопарк:

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

Не как с игрушкой "сгенерируй мне функцию".

Токены легко воспринимать как техническую мелочь.

Ну потратил агент 200 тысяч токенов. Ну еще 500 тысяч. Ну несколько долларов. Ну еще немного.

Но когда агентов становится несколько, задач много, а сессии длинные, стоимость начинает иметь значение.

Особенно если часть работы не дала результата.

Мне было важно видеть не просто "агент работал", а связь между ценой и пользой.

Например:

Это уже не просто биллинг.

Это обратная связь по процессу.

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

Без логов и стоимости это остается ощущением.

С логами это становится наблюдаемым процессом.

Для меня вся эта история не про "сделать еще одну обертку над AI".

Оберток уже хватает.

Мне нужна система, где через агентов можно реально вести разработку:

Пока это не идеальный автономный разработчик.

И, честно говоря, хорошо.

Я не очень верю в режим "мы нажали кнопку, и AI сам построил продукт". По крайней мере, не в той реальной разработке, где есть legacy, production, странные зависимости, клиенты, сроки, деньги и ответственность.

Но я верю в другой сценарий.

AI-агенты становятся рабочей силой внутри инженерного процесса.

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

И вот эта среда, как мне кажется, сейчас важнее очередного "супер-агента".

AI coding сейчас часто обсуждают через качество моделей.

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

Это важно.

Но в реальной работе быстро выясняется: модель — только часть системы.

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

Даже если модель сильная.

Потому что разработка — это не только код в файлах.

Это еще и решения вокруг кода.

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

Если всего этого нет в контексте, агент видит только поверхность.

Он может писать код, но не понимает историю проекта.

А без истории проекта он слишком часто делает вид, что разобрался.

Сейчас у меня собирается система, где AI-агенты работают не в пустоте, а внутри понятного рабочего процесса.

Есть задачи.

Есть агенты.

Есть история выполнения.

Есть стоимость.

Есть логи.

Есть изменения.

Есть контекст проекта, который не исчезает после закрытия сессии.

Это еще не финальная форма. Многое надо доводить, чистить, проверять на разных типах проектов, смотреть, где система сама усложняется и начинает мешать.

Но ощущение уже сильно другое.

Я перестал воспринимать AI-инструменты как отдельные чатики для генерации кода.

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

Для меня это и был главный смысл последних полутора месяцев.

Не сделать красивую панель.

Не написать еще один промпт.

Не собрать "AI-ассистента для разработчика" в абстрактном смысле.

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

Пока звучит просто.

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

Больше интересного про AI разработку, DevOps и IT у меня в тг, подписывайтесь

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