3,583 papers
arXiv:2610.36188 74 26 окт. 2026 г. FREE

Skill Dreaming: навыки репозитория, которые обновляются из истории pull request'ов

КЛЮЧЕВАЯ СУТЬ
Агент честно следует правилу, которое устарело неделю назад, и ломает код. Метод Skill Dreaming позволяет держать файл инструкций (CLAUDE.md, AGENTS.md) живым: после каждого принятого изменения кода модель сверяет новые правила со старыми. Каждое правило получает одну из семи меток: добавить, обновить, сузить, расширить, конфликт, заменить, оставить. Устаревшее уходит в архив с версией, а не копится. На тесте задач из реальных репозиториев это дало с 79% до 88% решённых задач на той же модели.
Адаптировать под запрос

Skill Dreaming — схема, в которой кодовый агент ведёт библиотеку навыков для конкретного репозитория и переписывает её после каждого нового pull request (PR, предложенного изменения кода). Из принятых PR и из неудачных попыток вытягиваются правила: когда навык применять, как делать, как проверить результат. Новые правила не просто складываются в кучу, а сверяются со старыми по семи операциям: добавить, обновить, сузить, расширить, отметить конфликт, заменить устаревшее, оставить как есть.

Боль знакомая каждому, кто ведёт файл инструкций для агента (CLAUDE.md, AGENTS.md, скилы). Репозиторий живёт, API меняется, договорённости сдвигаются. А старая инструкция остаётся и уводит агента к прежним приёмам, которые уже не работают. Агент честно следует устаревшему правилу и ломает то, что вчера было нормой. Обычный поиск по истории PR здесь не помогает: он достаёт старые примеры, но не отличает живое от протухшего.

Метод решает это так. После каждого PR автор навыков (та же LLM) пишет кандидатов в навыки по шаблону «условие → способ → проверка». Затем каждый кандидат сравнивается с уже существующими навыками и получает одну из семи меток. Устаревшие навыки не удаляются, а архивируются с привязкой к версии репозитория, и агент видит только активные. Сверху авторы показали прирост на бенчмарке задач из реальных репозиториев: с 79% до 88% решённых задач при той же модели.

🔬

Схема метода

ШАГ 1: Найти в истории PR, связанные с задачей → пометить: годится / можно починить / устарел / не относится / опасен
ШАГ 2: Собрать кандидатов: переиспользовать, починить или написать заново → прогнать тесты и проверки
ШАГ 3: Из успешных PR и из провалов написать навыки по шаблону «когда / как / как проверить» + запреты из ошибок
ШАГ 4: Сверить новые навыки со старыми → Add / Update / Specialize / Extend / Conflict / Supersede / Keep
ШАГ 5: Подать агенту ограниченное число подходящих активных навыков → он делает PR вместе с тестами, документацией и конфигом
ШАГ 6: Проверить результат, записать исход → он становится материалом для следующего круга

В статье это автоматический конвейер на коде (поиск по эмбеддингам, Docker, прогон тестов). Но сами шаги 3–5 повторяются вручную в обычном чате и в файле инструкций агента.

🚀

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

Сначала про границы. Метод сильнее всего там, где есть история изменений и автоматическая проверка: тесты, CI, ревью. Он слабее на проектах без тестов и на разовых задачах: навыкам не на чем «созревать». Поэтому берём живой проект с историей.

Задача: Небольшой интернет-магазин на Python/Django. Полгода назад команда подключила оплату через ЮKassa, потом добавила СБП, на прошлой неделе перевела все платежи на новый клиент SDK. В CLAUDE.md всё ещё написано, как «правильно» подключать платёжный провайдер по старой схеме. Агент в Claude Code регулярно делает новые интеграции по старой схеме, и тесты падают.

Промпт:

Ты — автор навыков для репозитория интернет-магазина (Django, платежи ЮKassa и СБП).

Ниже: (1) текущий навык «Подключение платёжного провайдера» из CLAUDE.md,
(2) diff и описание последнего принятого PR «Переход на новый клиент SDK ЮKassa»,
(3) комментарии ревью к этому PR и лог упавших тестов из первой попытки.

Сделай по шагам:
1. Из PR выпиши, что изменилось в соглашениях: что делать, чего больше не делать, что проверять.
2. Реши, что сделать с текущим навыком: Add / Update / Specialize / Extend / Conflict / Supersede / Keep. Обоснуй решением в одну-две фразы.
3. Если Supersede: перенеси старую версию в раздел «Архив» с пометкой, до какой версии SDK она действовала. Не удаляй.
4. Напиши обновлённый навык по шаблону: «Когда применять», «Как делать», «Как проверить», «Чего не делать» (из ошибок и правок ревью).
5. Отдельно перечисли обязательства, которые нужны вместе с кодом: тесты, документация, конфиг, changelog.

[текущий навык]
[diff и описание PR]
[комментарии ревью и лог тестов]

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

🧠

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

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

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

Как метод это использует. Он заставляет каждое новое знание пройти сверку с существующим и получить явное решение. Плюс правила держатся на доказательствах: к навыку привязаны PR, из которых он вышел, и версия репозитория.

Рычаги управления: - Число подаваемых навыков (в статье — жёсткий потолок) → меньше для простых задач, меньше шума в контексте. - Блок «Чего не делать» → его строят из провалов и правок ревью; убери, если ошибок ещё не набралось. - Список операций → для небольшого файла хватит трёх: Add, Update, Supersede. - Архив вместо удаления → оставляй, если проект часто откатывает изменения; иначе файл можно чистить. - Шаблон «когда / как / как проверить» → добавь свои блоки, например «риски».

📋

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

Ты — автор и хранитель навыков репозитория {проект}.

Дано:
<текущие_навыки>{файл инструкций или список навыков}
<новый_PR>{описание и diff принятого изменения}
<ревью_и_проверки>{комментарии ревью, результаты тестов, упавшие попытки}

ШАГ 1. Оцени источник: PR годится / можно починить / устарел / не относится к делу / опасен.
Если не годится — остановись и объясни почему.

ШАГ 2. Выпиши кандидатов в навыки. Каждый строго по шаблону:
- Когда применять: {условие}
- Как делать: {шаги}
- Как проверить: {тест, команда, признак готовности}
- Чего не делать: {запреты из ошибок и правок ревью}
- Основание: {какие PR}, версия: {версия репозитория}

ШАГ 3. Сверь каждого кандидата с текущими навыками и выбери ровно одну операцию:
Add — такого навыка нет
Update — уточнить существующий новой информацией
Specialize — сузить условие применения
Extend — добавить совместимые шаги или обязательства
Conflict — правила несовместимы, нужно решение человека
Supersede — старое правило устарело: перенеси в «Архив» с версией, не удаляй
Keep — менять нечего
К каждому решению: одна фраза причины.

ШАГ 4. Выдай итоговый список активных навыков и отдельно «Архив».
Для Conflict сформулируй вопрос человеку и не выбирай сторону сам.
Отдельным блоком перечисли обязательства вместе с кодом: тесты, документация, конфиг, примеры, changelog.

Что подставлять: {проект} — название и стек; файл инструкций вставь целиком; PR — описание плюс изменения кода; ревью и проверки — всё, что показало ошибки. Для следующего PR запускай шаблон снова с обновлённым списком навыков.

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

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

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

LLM спросит про текущий файл инструкций, последний принятый PR и результаты проверок — потому что метод опирается на сверку нового со старым и на сигналы тестов и ревью. Она возьмёт структуру операций и адаптирует под твой файл.

⚠️

Ограничения

⚠️ Нужен код и инфраструктура: в статье это конвейер с поиском по эмбеддингам, разбором коммитов, Docker и автоматическим прогоном тестов. В чате воспроизводится лишь ядро — сверка и переписывание навыков.

⚠️ Опора на проверки: метод держится на тестах и CI. Без них нет сигнала, что PR «успешный», и навыки накапливают непроверенные догадки.

⚠️ Свежесть — на вашей совести: вручную придётся каждый раз приносить новый PR и результаты. Забыл обновить — навык снова устарел.

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

⚠️ Конфликты не решаются сами: правила могут оказаться несовместимыми, и выбирать придётся человеку.

🔍

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

Исследователи собрали оценку на SWE-bench Pro (задачи из репозиториев Ansible, qutebrowser, Open Library) и SWE-bench Verified (12 репозиториев). Для каждой задачи брали исторический срез репозитория и использовали только те PR и навыки, что существовали до неё, чтобы будущее не «подсматривалось». Агентом служил mini-swe-agent на моделях семейства Claude (Opus-5 и Sonnet-4.6).

Сравнивали с классическим поиском по истории (BM25, плотные эмбеддинги, гибрид) и с пятью свежими методами обучения навыкам (Trace2Skill, Learning to Commit, SkillLens, CODESKILL, Socratic-SWE). Отдельные проверки отключали части метода: без навыков, только дописывание, только удачные примеры, без фильтра устаревших.

Главный результат: официальная доля решённых задач выросла с 79% до 88%. Дополнительно измеряли «покрытие обслуживания»: делает ли агент не только код, но и тесты, документацию, конфиг и changelog. Идея в том, что агент с навыками обслуживает репозиторий целиком, а не затыкает одну дыру.

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

💡

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

🔧 Техника: добавить блок «Чего не делать» → агент перестаёт повторять прошлые ошибки

В каждый навык добавь раздел «Чего не делать» и заполняй его из комментариев ревью и упавших тестов. Формулируй как запрет с причиной: «Не используй старый клиент ЮKassa: он ломает возвраты».

🔧 Техника: ввести версию в навык → меньше путаницы при откатах

К каждому навыку добавь поле «Действует с версии … по версию …». Агент проверяет её перед применением.

Для файла инструкций, который ведёт одна команда, можно сократить цикл до еженедельной ревизии:

Вот мой CLAUDE.md и список PR за неделю. Для каждого правила в файле укажи: подтверждено / устарело / противоречит новым PR. Для устаревших предложи замену и перенеси старую версию в «Архив».

🔗

Ресурсы

Skill Dreaming: Evolving Repository Skills through Pull Request Streams. Авторы: Xinyuan Song, Ryan Turner, Hasibul Haque, Bowen Zhu, Jay Somasundaram, Liang Zhao (Causal Dynamics Lab, США). Опираются на SWE-bench Pro, SWE-bench Verified, mini-swe-agent, а также на работы Learning to Commit, Trace2Skill, SkillLens, CODESKILL, Socratic-SWE.


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

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

Агент честно следует правилу, которое устарело неделю назад, и ломает код. Метод Skill Dreaming позволяет держать файл инструкций (CLAUDE.md, AGENTS.md) живым: после каждого принятого изменения кода модель сверяет новые правила со старыми. Каждое правило получает одну из семи меток: добавить, обновить, сузить, расширить, конфликт, заменить, оставить. Устаревшее уходит в архив с версией, а не копится. На тесте задач из реальных репозиториев это дало с 79% до 88% решённых задач на той же модели.

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

Новое правило не дописывается в конец. Оно проходит сверку со старыми. Работает как редактор в газете: он не складывает все заметки подряд, а решает, что заменяет вчерашнюю, а что дополняет. Каждое правило подписано шаблоном: когда применять, как делать, как проверить, чего не делать. К нему привязаны изменения, из которых оно вышло, и версия проекта. Если два правила несовместимы, модель не выбирает сама. Она задаёт вопрос человеку.

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

Для модели всё, что есть в файле, одинаково правда. Она не чувствует возраст инструкции. Дописываешь новое в конец, и в файле живут два способа подключить оплату. Оба «правильные». Зато модель отлично сравнивает два текста и находит, где они спорят. Тесты и замечания ревью дают ей внешний сигнал: что сработало, а что нет. Правило с привязкой к источнику и версии легко проверить и снять, когда оно протухло. Обычный поиск по истории изменений этого не умеет: он достаёт старые примеры, но не отличает живое от мёртвого.

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

Разработка → ведение файла инструкций для кодового агента, особенно когда проект меняется каждую неделю (смена библиотеки, новые договорённости, переход на другой SDK) и агент делает по-старому. Нужны история изменений и автоматическая проверка: тесты, CI, ревью. НЕ подходит для проектов без тестов и для разовых задач: правилам не на чем «созревать».

Мини-рецепт

1. Собери три куска: текущие правила, описание свежего принятого изменения, замечания ревью и лог упавших тестов
2. Проверь источник: пусть модель скажет, годится ли изменение, устарело ли оно или опасно. Не годится — стоп
3. Выпиши кандидатов: каждый строго по шаблону «когда применять / как делать / как проверить / чего не делать»
4. Сверь со старым: на каждого кандидата ровно одна метка из семи и одна фраза причины
5. Не удаляй, а архивируй: замененное правило уходит в раздел «Архив» с пометкой версии
6. Конфликт отдай человеку: пусть модель сформулирует вопрос, а не выбирает сторону
7. Повторяй на каждом новом изменении с уже обновлённым списком. Для маленького файла хватит трёх меток: добавить, обновить, заменить

Примеры

[ПЛОХО] : Вот новый pull request про переход на новый SDK оплаты. Допиши это в CLAUDE.md
[ХОРОШО] : Ты — автор и хранитель правил для репозитория интернет-магазина на Django. Дано: текущее правило «Подключение платёжного провайдера», описание принятого изменения «Переход на новый клиент SDK ЮKassa», замечания ревью и лог упавших тестов. Реши, что делать с правилом: добавить, обновить, сузить, расширить, отметить конфликт, заменить или оставить. Обоснуй одной фразой. Если заменить — перенеси старую версию в «Архив» с пометкой, до какой версии SDK она действовала. Напиши обновлённое правило: когда применять, как делать, как проверить, чего не делать. Отдельно перечисли, что нужно вместе с кодом: тесты, документация, конфиг.
Источник: Skill Dreaming: Evolving Repository Skills through Pull Request Streams
ArXiv ID: 2610.36188 | Сгенерировано: 2026-10-29 13:18

Проблемы LLM

ПроблемаСутьКак обойти
Модель слепо следует устаревшей инструкцииДля модели всё написанное в файле инструкций одинаково верно. Она не знает, что правило устарело. Проект меняется: новые библиотеки, новые договорённости. Старое правило остаётся. Модель честно делает по нему и ломает то, что вчера было нормой. Если дописывать новое в конец, файл начинает противоречить сам себеНе копи правила в конец. Перед добавлением нового правила проси модель сверить его со старыми и выбрать одно решение: добавить, уточнить, заменить или оставить. Устаревшее не удаляй, а переноси в раздел «Архив» с пометкой, до какого момента оно действовало

Методы

МетодСуть
Сверка нового знания со старым — файл инструкций не гниётДай модели три вещи: текущие правила, описание свежего изменения и результаты проверок (тесты, замечания ревью). Попроси сначала оценить, можно ли доверять источнику. Затем выписать кандидатов в правила по шаблону: когда применять / как делать / как проверить / чего не делать. Потом для каждого кандидата выбрать ровно одну операцию: добавить, обновить, сузить условие, расширить, отметить конфликт, заменить устаревшее или оставить как есть. К каждому решению — одна фраза причины. Почему работает: модель хорошо сравнивает два текста и находит, что в них несовместимо. Явная метка не даёт правилам тихо накапливаться. Тесты и замечания ревью дают внешний сигнал, что сработало, а что нет. Когда применять: у проекта есть история изменений и автоматическая проверка. Когда не работает: нет тестов, разовая задача, правилам не на чем «созревать»
Архив вместо удаления — устаревшее не мешает и не теряетсяЗаменённое правило не стирай. Перенеси в отдельный раздел с пометкой версии, до которой оно было верным. Модели показывай только действующие правила. Почему работает: модель не путается в двух версиях одного правила, а человек может вернуть старое при откате. Когда применять: проект часто откатывает изменения. Когда не нужно: маленький файл, откатов нет — старое можно просто чистить
Запреты из ошибок — правило «чего не делать»Каждую неудачную попытку и каждое замечание ревью превращай в короткий запрет внутри правила. Пример: Не использовать старый клиент, он сломает тесты. Почему работает: запрет привязан к реальному провалу, а не к догадке. Модель видит, где именно она раньше ошибалась. Когда нет: ошибок ещё не набралось — блок оставь пустым

Тезисы

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

Skill Dreaming: Evolving Repository Skills through Pull Request Streams

arXiv: 2610.36188

LLM-агенты безбожно тупят на длинной дистанции по одной причине: для модели любая старая инструкция — абсолютная правда. Когда разработчики месяцами дописывают новые правила проекта в конец системного файла, он превращается в свалку. Модель видит в одном контексте два взаимоисключающих способа решения, считает оба верными и выдаёт полную кашу. Метод Skill Dreaming решает эту проблему в корне: он заставляет навыки агента эволюционировать через поток Pull Request-ов, а не тупо раздувает контекст.

Это как джуниор, который клеит на монитор каждый совет тимлида и никогда их не снимает. Через полгода на экране висит стикер «делай только так» прямо поверх записки «так делать категорически нельзя». Джун ловит паническую атаку, пытается совместить несовместимое и выдаёт полный провал. Чтобы агент не сходил с ума, базу знаний нужно регулярно «пересобирать во сне», безжалостно вычищая протухшие костыли.

Вместо бесконечного списка запретов здесь работает эволюция навыков через CI/CD. Метод прогоняет цепочки изменений из гита, валидирует их через автоматические тесты и оставляет только жизнеспособный код. Устаревшие инструкции отмирают сами собой, а удачные решения закрепляются на базе реальных код-ревью. Никакой философии: только зелёные пайплайны определяют, какое знание имеет право остаться в памяти.

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

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

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

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

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