3,583 papers
arXiv:2608.14036 76 14 авг. 2026 г. FREE

SKILL.md: почему сжатая инструкция обходит модель лучше, чем история прошлых попыток

КЛЮЧЕВАЯ СУТЬ
Парадокс: чем больше прошлых попыток агента запихиваешь в контекст, тем хуже он работает. Метод позволяет один раз сжать удачные и неудачные попытки в короткий чек-лист — и больше не тратить время на повторные правки одних и тех же ошибок. Документ-инструкция работает не как источник новых знаний, а как якорь: он держит модель на рельсах правильной последовательности действий. Модель получает не сырые логи, а сжатую процедуру из трёх частей — и перестаёт путать ошибку с нормой.
Адаптировать под запрос

TL;DR

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

Главная боль: если закинуть модели весь «архив» прошлых попыток — включая тупиковые ветки, лишние исследования, повторяющиеся ошибки — модель тратит внимание на этот шум и чаще срывает таймауты или теряет фокус. Причина проста: сырая история — это не инструкция, а поток данных, в котором полезное перемешано с мусором.

Решение — не давать модели сырые логи, а заранее дистиллировать их в компактный документ-процедуру. Такой документ работает как «якорь»: держит модель на рельсах правильной последовательности действий, а не сообщает ей новые знания. Отдельная находка: если у вас много таких документов (база знаний, файлы проекта), модель резко хуже находит нужный по мере роста их числа — значит, базу нужно держать маленькой и тематически разбитой.

🔬

Схема метода

ШАГ 1: Соберите 3-8 примеров прошлых попыток (удачных и неудачных) → сырые тексты/логи
ШАГ 2: Попросите LLM выделить из них общую процедуру, а не пересказать примеры → 
        документ из 3 частей: "что делать", "что проверять", "чего избегать"
ШАГ 3: Сохраните документ как персистентную инструкцию (Custom Instructions / Project Knowledge) 
        и используйте вместо повторной вставки примеров каждый раз

Все шаги можно сделать в одном чате последовательно.

🚀

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

Задача: Вы ведёте соцсети бренда и каждый раз просите ChatGPT написать пост, а потом правите одно и то же: слишком длинно, нет призыва к действию, не тот тон. Хочется один раз «зашить» это в инструкцию, а не объяснять заново в каждом чате.

Промпт:

У меня есть 5 постов, которые получились хорошо, и 3, которые не подошли 
(слишком длинные, без призыва к действию, не в тоне бренда — 
он ироничный, без канцелярита, обращение на "ты").

Вот они: {вставить тексты постов с пометкой удачный/неудачный}

Изучи их и составь короткую инструкцию из трёх частей:
1. Что делать (порядок действий при написании поста)
2. Что проверять перед публикацией (чек-лист)
3. Каких ошибок избегать

Не пересказывай примеры дословно — выведи из них общее правило.

Результат: Модель выдаст компактный документ на 10-15 строк с тремя разделами. Дальше вы вставляете этот документ в начало любого нового чата про посты (или кладёте в Custom Instructions / Project) — вместо того чтобы каждый раз копировать старые примеры целиком.

🧠

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

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

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

Рычаги управления: - Число исходных примеров для дистилляции (3-8 достаточно) → больше — не значит лучше, качество важнее количества - Раздел «чего избегать» → можно расширять на основе конкретных повторяющихся правок - Формат чек-листа → чем короче и конкретнее пункты, тем стабильнее модель их соблюдает

📋

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

У меня есть {N} примеров, которые получились удачно, и {N} примеров, 
которые не подошли, для задачи: {описание задачи}.

Удачные примеры: {вставить}
Неудачные примеры и что в них не так: {вставить}

Составь короткую инструкцию из трёх частей:
1. Что делать (порядок действий)
2. Что проверять перед финальным ответом
3. Каких ошибок избегать

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

Подставьте вместо {описание задачи} — тип работы (посты, письма клиентам, отчёты), вместо примеров — реальные тексты с пометкой «удачно/неудачно».

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

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

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

LLM спросит, какие у вас есть удачные и неудачные примеры и почему — потому что без чёткой разметки «что сработало, что не сработало» дистилляция в процедуру не получится. Дальше она сама соберёт чек-лист по паттерну из шаблона.

⚠️

Ограничения

⚠️ Растущая база знаний вредит поиску: если у вас много таких документов-чек-листов (файлы в Project, база знаний Custom GPT), модель резко хуже находит нужный по мере роста их числа — точность падает с ~30% до ~3% при увеличении пула с 5 до 100 документов. Держите базу маленькой и разделённой по темам.

⚠️ Не гарантирует успех даже при точном совпадении: даже если модель нашла и использует «правильный» чек-лист, это не гарантирует хороший результат — если задача чуть отличается от той, для которой писали инструкцию, чек-лист может не подойти или сбить с толку.

⚠️ Работает для процедурных задач, не для творческих: метод хорош там, где важна стабильность выполнения (форматы, регулярные операции, проверки). Для субъективных творческих задач (придумать оригинальную идею) эффект слабее — там нет «правильной последовательности», которую можно зафиксировать.

🔍

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

Команда взяла AI-агентов (Codex и Gemini CLI), которые выполняют реальные задачи в терминале — настройка окружений, работа с кодом, тестами — на бенчмарках Terminal-Bench и SkillsBench. Они сравнили три варианта: агент без подсказок, агент с сырой историей прошлых попыток (Workflow Memory) и агент с дистиллированным чек-листом (Skill), при этом исходные трейсы были одинаковыми во всех случаях — менялось только их представление.

Дальше исследователи разметили вручную 240 трейсов выполнения, выделив 12 типовых причин успеха и провала, и проверили разметку человеком — совпадение с LLM-разметкой оказалось 95.8% (это очень высокий показатель надёжности). Оказалось, что дистиллированный чек-лист помогает в основном за счёт «процедурного якоря» (65.7% случаев), а не за счёт новых фактов (всего 4.5%) — это и есть главный неожиданный вывод: сырой опыт был не полезен сам по себе, полезна была именно его сжатая форма.

Отдельно проверили retrieval — насколько легко найти нужный документ среди похожих, увеличивая библиотеку с 5 до 100 документов. Точность поиска рухнула почти в 10 раз, но что удивительно — итоговый успех задачи при этом падал не так резко: точный выбор документа не был ни строго необходимым, ни достаточным условием успеха.

🔗

Ресурсы

DemystifyingAgentSkills: Why They Work—Until They Don't. Авторы: Zhiyuan Jiang, Fangrui Huang, Hanwen Xing и др. Princeton University, Stanford University, UC San Diego, USC, Johns Hopkins University. Использованные бенчмарки: Terminal-Bench, SkillsBench.


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

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

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

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

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

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

Модель плохо держит фокус в длинном грязном контексте — путает случайность и правило. Зато отлично следует явной короткой инструкции, если в ней чётко расписан порядок и точки проверки. Дело не в новых знаниях — дело в том, что чек-лист фиксирует поведение модели, а не расширяет её память. Именно поэтому 3-8 примеров для дистилляции работают не хуже, чем 50 — важно качество разметки, а не объём.

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

Работает для агентных задач с повторяющейся процедурой → регулярные посты, отчёты, форматированные ответы, где важна стабильность выполнения. Особенно ценно когда вы каждый раз правите одни и те же ошибки в ответах модели. НЕ подходит для творческих задач без чёткой последовательности — и не копите десятки чек-листов в одной базе: точность их поиска падает с 30% до 3% при росте пула с 5 до 100 документов.

Мини-рецепт

1. Собери примеры: 3-8 прошлых попыток, удачных и неудачных, с явной пометкой почему не подошло
2. Попроси LLM дистиллировать: не пересказать примеры, а вывести из них общее правило — три части: что делать, что проверять, чего избегать
3. Сохрани как постоянную инструкцию: вставляй в начало нового чата или положи в Custom Instructions / Project Knowledge вместо повторной вставки примеров
4. Держи базу маленькой: если чек-листов становится много — разбей по темам, а не складывай всё в одну кучу

Примеры

[ПЛОХО] : Вот 10 моих прошлых постов, удачных и неудачных, напиши похожий пост про новую фичу
[ХОРОШО] : Изучи 5 удачных и 3 неудачных поста (вот они с пометками, что не так в неудачных). Составь инструкцию из трёх частей: что делать, что проверять, чего избегать. Не пересказывай примеры — выведи общее правило
Источник: DemystifyingAgentSkills: Why They Work-Until They Don't
ArXiv ID: 2608.14036 | Сгенерировано: 2026-08-17 05:23

Проблемы LLM

ПроблемаСутьКак обойти
Сырая история прошлых попыток сбивает модель с курсаЕсли скормить модели весь архив прошлых попыток — удачных и неудачных вперемешку — она путает, что было ошибкой, а что нормой. Тратит внимание на детали, которые к задаче не относятся. Чем длиннее и грязнее этот "архив", тем выше риск, что модель отвлечётся, забудет ключевое требование или сорвёт таймаутНе вставляй сырые логи и примеры каждый раз заново. Заранее сожми их в короткий документ: что делать, что проверять, чего избегать. Вставляй только этот документ
Поиск нужного документа рушится при росте базы знанийЕсли у тебя много похожих файлов-инструкций (база знаний, файлы проекта, Custom GPT), модель резко хуже находит среди них нужный по мере роста их числа. При росте пула документов с единиц до сотни точность падения найти правильный документ обрушивается почти до нуляДержи базу маленькой и разбитой по темам. Не копи десятки похожих чек-листов в одном месте — лучше несколько узких баз, каждая под свою задачу

Методы

МетодСуть
Дистилляция прошлых попыток в короткий чек-листСобери 3-8 примеров прошлых попыток (удачных и неудачных, с пометкой почему). Попроси модель не пересказать их, а вывести общую процедуру: 1. Что делать 2. Что проверять 3. Чего избегать. Сохрани результат как постоянную инструкцию (Custom Instructions / Project Knowledge) вместо повторной вставки примеров. Почему работает: короткая явная процедура держит модель на нужной последовательности действий, а не просто добавляет ей знаний. Работает: процедурные, повторяющиеся задачи (форматы, регулярные проверки, шаблонные тексты). Не работает: творческие задачи, где нет "правильной последовательности" — там сравнивать не с чем
📖 Простыми словами

DemystifyingAgentSkills: Why They Work-Until They Don't

arXiv: 2608.14036

Суть в том, что AI-агенты тупят не от недостатка знаний, а от банальной потери фокуса. Когда мы пытаемся обучить модель на ее прошлых ошибках, мы обычно вываливаем на нее гору логов: «смотри, тут ты облажалась, а тут сделала нормально». Но для нейронки это превращается в информационный шум, где она тупо путает правильные действия с косяками. Исследование доказывает, что магия не в объеме данных, а в структурированной процедуре. Модель работает четко только тогда, когда у нее перед глазами есть жесткий чек-лист, который удерживает ее в рамках и не дает «расползтись» мыслями по древу.

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

Исследователи сравнили два подхода: сырые логи против сжатых навыков (Agent Skills). Выяснилось, что когда ты скармливаешь модели тонну примеров «как надо и как не надо», она начинает лажать из-за перегруза контекста. А вот дистиллированный чек-лист, собранный из тех же самых попыток, превращает модель в профи. Работает это просто: берем прошлый опыт, выкидываем мусор, оставляем только конкретные правила проверки и ошибки, которых надо избегать. В итоге точность растет, потому что модель тратит ресурс на выполнение задачи, а не на попытки разобраться в твоих старых логах.

Этот принцип универсален и применим везде — от написания постов для соцсетей до сложного кодинга. Если ты каждый раз правишь за ChatGPT одни и те же косяки вроде «слишком много прилагательных» или «забыл вставить ссылку», бесполезно просто кидать ему примеры старых чатов. Нужно создать документ-инструкцию, который станет для него внешним скелетом. Тестировали это на агентах, но механика одинакова для любого промптинга: четкий перечень «что проверять» бьет любые попытки научить модель «на примерах» в 10 случаях из 10.

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

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

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

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