7 760 статей
arXiv:2611.04466 86 3 нояб. 2026 г. FREE

VibeTrace (Observe → Understand → Intervene → Evolve): точечный откат траектории кодинг-агента и превращение правок человека в переиспользуемые скилы

КЛЮЧЕВАЯ СУТЬ
Проблема: в обычном чате с кодинг-агентом правка ошибки в конце диалога размазывает баг по контексту, а сброс сессии сжигает всю верную разведку первых шагов. Цикл VibeTrace позволяет откатить агента ровно к шагу перед сбоем и превратить вашу подсказку в многоразовый навык. Фишка метода: сравнение ошибочной и исправленной веток с общим корнем сразу переплавляется в постоянный скил. Такая онлайн-дистилляция траектории сохраняет найденные файлы и экономит 23% входных токенов на будущих задачах.
Адаптировать под запрос
⚡

TL;DR

VibeTrace — система и четырёхшаговый цикл совместной работы человека с кодинг-агентом (Observe → Understand → Intervene → Evolve), которые превращают линейный лог выполнения в интерактивное дерево действий с возможностью ответвиться (fork) с любого прошлого шага и автоматически упаковать удачную правку разработчика в переиспользуемый скил (модуль навыков агента). Вместо пассивного наблюдения за тем, как агент уходит не в ту степь, разработчик точечно перенаправляет его с места поломки, сохраняя всю валидную работу до этого шага.

В обычных чатах и терминальных агентах (Claude Code, Cursor, Codex, OpenCode) работа устроена по принципу «только вперёд»: когда агент на десятом шаге выбирает неверную архитектуру или ломает рабочие тесты, у разработчика есть два плохих выхода. Если писать замечания дальше в конец чата — ошибка уже размазана по контексту и файлам; если остановить сессию и перезапустить задачу с нуля — сгорает вся удачная разведка репозитория и верные правки первых шагов, а через день на похожей задаче агент повторит ту же самую ошибку.

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


🔬

Схема метода

ШАГ 1 (Observe — Наблюдение): Запись каждого шага агента как структуры (действие, входное состояние, артефакт, время/токены, итоговое состояние) → [Иерархическая карта траектории вместо простыни текста]
ШАГ 2 (Understand — Диагностика): Отслеживание связей между действиями и поиск красного узла, где план или команда пошли не так → [Точка расхождения]
ШАГ 3 (Intervene — Ветвление): Откат (fork) к шагу перед ошибкой с целевой корректировкой человека при сохранении валидного контекста → [Новая успешная ветка решения]
ШАГ 4 (Evolve — Дистилляция в скил): Сравнение ошибочной и исправленной веток и упаковка правила/стратегии человека в переиспользуемый скил → [Обновлённый пул скилов агента]

В системе VibeTrace (надстройка над OpenCode) все 4 шага работают через визуальный интерфейс, а в стандартных агентах (Claude Code, Cursor) шаги 3 и 4 воспроизводятся через ветвление сессии (/rewind / fork) и промпт дистилляции правки в SKILL.md.


🚀

Пример применения

Задача: Тимлид финтех-команды поручает кодинг-агенту добавить идемпотентную обработку вебхуков Системы быстрых платежей (СБП) в сервис оплаты на FastAPI. Первые 5 шагов агент делает отлично: находит нужные роуты, изучает схему БД и модели платежей. Но на 6-м шаге вместо блокировки строки в PostgreSQL (SELECT ... FOR UPDATE) агент начинает городить самописный кэш в оперативной памяти процесса, который развалится при запуске нескольких воркеров Gunicorn.

Промпт (для дистилляции вмешательства человека в переиспользуемый скил на шаге Evolve):

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

Контекст задачи:
Добавление идемпотентной обработки вебхуков оплаты СБП в FastAPI-бэкенд.

Валидный прогресс до точки ветвления (Шаги 1–5):
Агент корректно нашёл эндпоинт `/api/v1/sbp/webhook`, схему таблицы `payment_events` и тесты в `tests/test_webhooks.py`.

Ошибочное действие агента в узле ветвления (Шаг 6, старая ветка):
Агент попытался реализовать защиту от дублей вебхуков через глобальный `dict` в памяти Python-процесса (`_processed_ids = set()`).

Моё вмешательство и корректировка (Шаг 6', новая ветка):
Откат к Шагу 5 с инструкцией: «Сервис работает в нескольких воркерах Gunicorn, хранить состояние идемпотентности в памяти процесса запрещено. Используй уникальный индекс по `operation_id` в PostgreSQL (`INSERT ... ON CONFLICT DO NOTHING`) и транзакционную блокировку `SELECT ... FOR UPDATE`».

Сформируй из этого сравнения компактный переиспользуемый скил:
1. Название и условие активации (когда загружать скил).
2. Антипаттерн (какое решение агента было ошибочным и почему).
3. Проверенная процедура (пошаговый порядок действий, который привёл к успешной ветке).

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


🧠

Почему это работает

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

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

Цикл VibeTrace объединяет эти свойства: он фиксирует каждый шаг в виде проверяемой пятёрки $(a_i, s_i, o_i, t_i, r_i)$ — действие, состояние до, артефакт, время/токены, состояние после — и превращает точку вмешательства человека в обучающий контраст «как агент хотел сделать vs как человек его направил». Дистилляция этого контраста прямо в момент починки создаёт живой скил, привязанный к реальному контексту выполнения.

Рычаги управления: - Гранулярность осмотра (Trace Cards vs узлы действий) → сначала смотрите на карточку этапа (расход токенов, стоимость, число вызовов LLM и красные флаги ошибок), и раскрывайте граф отдельных действий только там, где метрики или результат просели. - Точка ответвления (Fork) → откатывайтесь ровно к тому узлу, где разведка файлов уже завершена, но неверная правка кода ещё не внесена: это экономит токены на повторном чтении репозитория. - Онлайн-дистилляция после правки → превращайте вмешательство в скил только тогда, когда исправленная ветка прошла проверку и содержит повторяющийся паттерн проекта, чтобы не засорять пул скилов разовыми опечатками.


📋

Шаблон промпта

Ты — модуль онлайн-дистилляции опыта совместной работы разработчика и кодинг-агента (Online Trace-to-Skill Distillation).

Исходная задача:
{описание_задачи}

Общая валидная история до точки вмешательства (сохранённый контекст):
{валидные_шаги_до_форка}

Отклонённая ветка агента (действие, состояние, ошибка/причина отклонения):
{ошибочный_шаг_и_следствие}

Вмешательство человека и успешная ветка (корректировка и итоговые шаги):
{корректировка_человека_и_результат}

Сформируй переиспользуемый скил для пула навыков агента по следующей структуре:
- Имя скила: {короткий_глагольный_заголовок}
- Условия активации (When to use): при каких признаках задачи и состояния среды вызывать этот скил.
- Диагностика сбоя (What to avoid): какой шаг агента приводит к ошибке и по какому признаку его распознать в траектории.
- Рабочая процедура (Execution strategy): точная последовательность действий и проверок из успешной ветки.

Что подставлять в плейсхолдеры: - {описание_задачи} — формулировка тикета или задачи на разработку. - {валидные_шаги_до_форка} — какие файлы и состояния агент успешно собрал до ошибки. - {ошибочный_шаг_и_следствие} — действие, на котором агент свернул не туда. - {корректировка_человека_и_результат} — инструкция, которой вы перенаправили агента, и успешный исход новой ветки.

🚀 Быстрый старт — вставь в чат:

Вот шаблон дистилляции вмешательства в скил из метода VibeTrace. Адаптируй под мою задачу: [твоя задача]. 
Задавай вопросы, чтобы заполнить поля.

[вставить шаблон выше]

LLM спросит, на каком шаге ваш кодинг-агент свернул не туда и какой командой вы его поправили, после чего соберёт готовый блок для вашего SKILL.md или CLAUDE.md.


⚠️

Ограничения

⚠️ Привязка готового визуального интерфейса к OpenCode: Готовая система визуализации графа и интерактивного форка VibeTrace построена поверх открытого агента OpenCode. При работе в закрытых средах (Claude Code, Cursor) визуального дерева веток из коробки нет — там метод применяется через штатный откат шагов (/rewind / чекпоинты) и сохранение скилов в .claude/skills/.

⚠️ Умеренный прирост точности при большой экономии токенов: На бенчмарке SWE-bench Verified накопленные скилы дают в первую очередь экономию ресурсов (снижение входных токенов на 23% и стоимости на 15,5%), тогда как итоговая доля решённых задач растёт умеренно (на 3 процентных пункта).


🔍

Как исследовали

Команда из Университета Тунцзи (Шанхай) и Лундского университета (Швеция) начала с глубокого интервью 12 практиков со средним опытом разработки почти 5 лет (8 программистов, 2 продакт-менеджера и 2 UI/UX-дизайнера), которые больше года ежедневно работают в Claude Code, Codex, Cursor и OpenCode. Разбор реальных кейсов показал пять системных проблем: разработчики не доверяют текстовым самоотчётам агента без привязки к реальным вызовам инструментов, не видят причинно-следственной связи между ранним неверным допущением в плане и поздним падением теста, теряют валидный прогресс при перезапуске сбившегося агента и вынуждены из раза в раз вручную повторять одни и те же проектные правки. На основе этих находок авторы построили систему VibeTrace поверх OpenCode, которая группирует 12 базовых действий агента в 7 категорий (планирование, сбор контекста, модификация кода, коммуникация, работа со скилами, исполнение команд и сжатие контекста), строит иерархические карточки с расходом токенов и временем каждого шага, позволяет форкать выполнение с любой точки и автоматически дистиллирует успешные правки человека в скилы. Проверка на бенчмарке SWE-bench Verified показала, что дистиллированные из траекторий скилы сокращают расход входных токенов на 23,0% и стоимость прогона на 15,5%, одновременно повышая долю решённых задач с 65,0% до 68,0%, а лабораторное исследование с пользователями и экспертные интервью подтвердили, что визуальные карточки траекторий позволяют находить причину ошибки агента быстрее и точнее, чем чтение обычных логов чата.


💡

Адаптации и экстраполяции

🔧 Техника: Правило «Чекпоинт после разведки» в CLAUDE.md → дешёвый откат без потери контекста в любом консольном агенте

Поскольку в исследовании показано, что главная потеря при перезапуске агента — сгорание уже собранного контекста репозитория (Information Acquisition), разделите работу агента в CLAUDE.md на два явных этапа:

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

Экстраполяция на командную базу знаний (Team Skill Pool): В конце рабочего дня или при закрытии сложного пул-реквеста прогоняйте сессии, где разработчику пришлось вручную поправлять агента, через шаблон дистилляции VibeTrace и коммитьте полученные файлы скилов в общую папку репозитория (.claude/skills/ или .cursor/rules/). Так удачная правка одного сеньора мгновенно страхует агентов всей команды от повторения той же ошибки.


🔗

Ресурсы

[From Watching to Steering: Enabling Human–Coding Agent Collaboration through Execution Traces] [https://arxiv.org/abs/2611.04466, код системы VibeTrace: https://github.com/idvxlab/VibeTrace] [Xiaoke Yan, Jiaying Lei, Danqing Shi, Zichen Wang, Nan Cao — Tongji University, Lund University]


📋 Дайджест исследования

Ключевая суть

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

Принцип работы

Текстовым отчётам агента в чате верить нельзя: он бодро рапортует об успехе, пока внутри ломает архитектуру. Линейный чат работает как дорога без разворотов — либо терпишь мусор в истории, либо начинаешь маршрут с нуля. Веди работу по циклу: наблюдай реальные артефакты → найди узел поломки → ответвись (fork) → сожми правку в скил. Когда разработчик останавливает агента на шестом шаге и даёт верное направление, рождается контраст «как агент хотел сделать vs как правильно в нашем проекте». Это как сохранение в игре перед боссом с записью победной тактики в гайд: не проходишь заново первые пять уровней и больше не наступаешь на те же грабли.

Почему работает

Опрос 12 практикующих разработчиков подтвердил: самое ценное знание о кодовой базе всплывает именно в момент ручного перехвата управления. Если зафиксировать каждый шаг как проверяемую пятёрку (действие, состояние до, артефакт, время с токенами и состояние после), точку сбоя видно сразу. А сопоставление старой тупиковой ветки и новой успешной даёт модели идеальный материал для правила. Накопленные так скилы режут расход входных токенов на 23% и снижают стоимость прогона на 15,5%, плюс добавляют 3 процентных пункта решённых задач на SWE-bench Verified.

Когда применять

Разработка с кодинг-агентами (Claude Code, Cursor, OpenCode) → конкретно для сложных задач в живых репозиториях, особенно когда агент отлично проводит разведку файлов на первых шагах, но затем выбирает кривую архитектуру. НЕ подходит для упаковки разовых опечаток в скилы — в библиотеку навыков стоит сохранять только повторяющиеся паттерны проекта.

Мини-рецепт

1. Проверяй артефакты, а не слова: смотри на реальные диффы, коды возврата и скачки токенов на каждом шаге.
2. Откатись в точку перед багом: сделай ветвление сессии (/rewind или fork) ровно на том шаге, где файлы уже найдены, но кривой код ещё не написан.
3. Дай точечную архитектурную правку: одной репликой укажи правильный паттерн для новой ветки и доведи задачу до зелёных тестов.
4. Выжми контраст в скил: скорми модели старую ошибочную и новую успешную ветки, чтобы она собрала правило для SKILL.md (когда включать, чего избегать и как делать).

Примеры

[ПЛОХО] : Ты на 6-м шаге написал кэш в памяти вместо PostgreSQL, переделай всё заново прямо тут в конце чата.
[ХОРОШО] : Сделай откат к шагу 5 (разведка роутов и БД сохранена). На шаге 6 используй SELECT ... FOR UPDATE в PostgreSQL вместо dict в памяти. После прохождения тестов сравни старую ветку (шаг 6) и новую (шаг 6') и запиши переиспользуемый скил: условие вызова, запрещённый антипаттерн и рабочую процедуру.
Источник: From Watching to Steering: Enabling Human-Coding Agent Collaboration through Execution Traces
ArXiv ID: 2611.04466 | Сгенерировано: 2026-11-09 04:06

Проблемы LLM

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

Методы

МетодСуть
Выжимка правки человека в навык на развилке ветокОткати диалог к последнему верному шагу перед сбоем. Дай модели правильную инструкцию и дождись рабочего решения. Затем подай в запрос обе ветки от общего корня: Валидные шаги, Ошибочный шаг агента, Корректировка человека и результат. Попроси сжать разницу в модуль навыка: условие вызова, чего избегать и проверенный порядок шагов. Почему работает: Контраст между неверным ходом модели и успешной правкой человека наглядно выделяет корень ошибки. Готовый навык экономит около четверти входных токенов на будущих похожих задачах. Когда применять: Повторяющиеся архитектурные ошибки проекта, где исправленная ветка уже прошла проверку. Когда не работает: Разовые опечатки и уникальные сбои, которые не встретятся снова

Тезисы

ТезисКомментарий
Контраст ошибочной и исправленной веток от общего шага даёт лучшие правила для агентаСамое ценное знание о проекте возникает в момент, когда человек перенаправляет агента на конкретном шаге. Сравнение двух веток от одной развилки позволяет выделить точный признак сбоя и рабочую процедуру без лишнего шума. Применяй: После удачного отката и починки проси модель сравнить старый и новый ход и записать правило в файл навыков
Накопленные навыки из прошлых правок экономят четверть входных токенов при росте точностиГотовые процедурные модули избавляют агента от повторной разведки файлов методом проб и ошибок. Входные токены снижаются на 23%, а стоимость решения падает на 15,5% при одновременном росте доли решённых задач. Применяй: Подключай проверенные навыки с пошаговыми процедурами перед стартом типовых задач в репозитории
📖 Простыми словами

From Watching to Steering: Enabling Human-Coding Agent Collaboration through Execution Traces

arXiv: 2611.04466

Кодинг-агенты сегодня работают как самоуверенные стажеры: они бодро рапортуют об успехах в чате, пока втихую сжигают ваш продакшен. Проблема в том, что современные LLM-разработчики живут в линейном логе, где каждая ошибка наслаивается на предыдущую. Если агент на десятом шаге свернул не туда, у тебя два пути: либо смотреть, как он закапывается всё глубже в свой же мусорный контекст, либо сносить всё к чертям и начинать заново. Система VibeTrace меняет саму механику: она превращает процесс из монолога в интерактивное дерево, где ты можешь буквально «отмотать» время и перехватить управление в точке поломки.

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

В основе лежит цикл из четырех шагов: Observe, Understand, Intervene, Evolve. Сначала ты видишь дерево действий, а не просто полотно текста. Когда агент вместо нормальной блокировки базы данных начинает городить костыли в оперативной памяти, ты делаешь Intervene — точечно правишь логику прямо в той ветке, где пошел перекос. Самый сок в этапе Evolve: твоя удачная правка не исчезает в истории чата, а упаковывается в переиспользуемый скилл. Агент запоминает этот маневр и в следующий раз уже не тупит, используя твой опыт как готовый модуль.

Исследование проводили на реальных задачах, и оно бьет в самую боль: текстовым отчетам AI нельзя верить. Модель может врать, что всё работает, скрывая фатальную ошибку в планировании пятью шагами ранее. VibeTrace вытаскивает эти скелеты из шкафа, позволяя разработчику не переписывать код за роботом, а рулить процессом. Это переход от пассивного наблюдения к хирургическому вмешательству, где сохраняется вся полезная работа, сделанная до момента факапа.

Короче: хватит пытаться «договориться» с агентом в чате, когда он уже поплыл — это бесполезно. Будущее за системами, которые позволяют ветвить выполнение и превращать твои исправления в постоянные навыки нейронки. Либо ты тратишь время на бесконечные промпты в надежде, что в этот раз он не ошибется, либо берешь VibeTrace и просто направляешь его по нужным рельсам. Контроль над контекстом — это единственное, что отделяет работающий софт от кучи сгенерированного мусора.

Работа с исследованием

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

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с