3,583 papers
arXiv:2606.20512 76 18 июня 2026 г. FREE

Probe-and-Refine: итеративная отладка инструкций через синтетические тест-кейсы

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

TL;DR

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

Главная находка: не важно есть ли у тебя инструкции или нет — важно как они сделаны. Инструкции, сгенерированные за один проход ("напиши мне хороший системный промпт"), иногда работают хуже нуля — LLM следует им буквально, даже когда они ведут в тупик. Проблема в том, что одноразовая генерация выдаёт общие советы: "проверяй факты", "анализируй тщательно". Это звучит разумно, но не говорит что именно делать в конкретных ситуациях.

Probe-and-Refine решает это через обратную связь от failures: генерируй тест-кейсы → смотри где инструкции не справляются → добавляй конкретные правила. Контент-анализ 104 добавленных правил через всю процедуру показал три устойчивых категории: процедурные правила (47% — "сначала воспроизведи ошибку, потом фикси"), структурные ссылки (30% — конкретные файлы, части, модули контекста), гейты качества (23% — "показывай реальный вывод, не придумывай").


🔬

Схема метода

Выполняется в одном разговоре с LLM или за 3–5 итераций отдельных сессий

ИТЕРАЦИЯ (повторить 3–5 раз):
  ШАГ 1: Генерация проб  → 5–10 синтетических тест-кейсов по твоей задаче
  ШАГ 2: Симуляция       → для каждого пробы: попытка решить по текущим инструкциям
  ШАГ 3: Диагностика     → СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ + причина провала
  ШАГ 4: Патч            → конкретные добавления в инструкции (макс. 5 правок)

  СТОП: если две итерации подряд — нет изменений

🚀

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

Задача: Паша — продакт в небольшом агентстве. Настроил Claude Project для анализа брифов от клиентов и подготовки предложений. Написал инструкции за 10 минут — "анализируй задачи клиента, формулируй ценность, предлагай решение". Claude выдаёт общие предложения, не учитывает индустрию клиента, не структурирует по разделам. Паша хочет улучшить инструкции, но не знает что именно не так.

Промпт:

У меня есть инструкции для Claude Project:

---
[ТЕКУЩИЕ ИНСТРУКЦИИ]
Анализируй бриф клиента. Выяви ключевую задачу. 
Предложи решение. Сформулируй ценность для бизнеса.
---

Моя задача: анализировать брифы от клиентов B2B-агентства и готовить 
коммерческие предложения.

Проведи зонд-итерацию:

**ШАГ 1. Синтетические пробы.**
Сгенерируй 5 тест-кейсов — разных по типу задач, которые 
я могу получить. Каждый: заголовок + краткое описание ситуации + 
что должны правильно обработать инструкции.

**ШАГ 2. Симуляция.**
Для каждой пробы: симулируй ответ по текущим инструкциям. 
Оцени: СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ.

**ШАГ 3. Диагностика.**
Для ЧАСТИЧНЫЙ и ПРОВАЛ: 1–2 предложения — чего именно 
не хватило в инструкциях.

**ШАГ 4. Патч.**
Предложи до 5 конкретных правок. Категории:
- Процедурные: пошаговые рабочие цепочки ("сначала X, потом Y")
- Структурные: специфичные под мой контекст (разделы, типы клиентов)
- Гейты качества: стандарты вывода ("всегда указывай ...", "не пиши ...")

**ШАГ 5. Обновлённые инструкции.**
Покажи патченную версию — не длиннее 1500 символов.

Результат: Модель покажет 5 симулированных ситуаций с оценками, для каждого провала — конкретный диагноз (например: "инструкции не задают структуру разделов предложения" или "нет правила про индустриальный контекст клиента"). В финале — обновлённые инструкции с процедурными правилами ("сначала определи индустрию, потом боль, потом формат"), структурными ссылками под твою специфику и гейтами качества.


🧠

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

Слабость LLM: модель следует инструкциям буквально. Если написано "анализируй тщательно" — она так и делает, но по своему усмотрению интерпретирует что значит "тщательно". Общие инструкции оставляют слишком большое пространство для интерпретации, и модель заполняет его своими паттернами — часто не теми.

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

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

Рычаги управления: - Количество проб (5 vs 10) → больше проб = глубже диагностика, но дольше. Для начала хватает 5 - Число итераций → стоп после 2 итераций без изменений — хороший критерий для любой задачи - Лимит символов инструкций → важно ограничивать. Длинные инструкции не лучше коротких — лучше правильные короткие - Категории патчей → можно убрать "структурные" если нет специфического контекста, или добавить свою категорию ("примеры формата вывода")


📋

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

У меня есть инструкции для {название_проекта/задачи}:

---
{текущие_инструкции}
---

Моя задача: {описание_чем_занимается_проект}.

Проведи зонд-итерацию:

**ШАГ 1. Синтетические пробы.**
Сгенерируй {5-10} тест-кейсов — разных по типу ситуаций. 
Каждый: заголовок + краткое описание + что должны обработать инструкции.

**ШАГ 2. Симуляция.**
Для каждой пробы симулируй ответ по текущим инструкциям. 
Оцени: СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ.

**ШАГ 3. Диагностика.**
Для ЧАСТИЧНЫЙ и ПРОВАЛ: чего именно не хватило в инструкциях (1–2 предл.).

**ШАГ 4. Патч.**
Предложи до 5 конкретных правок. Категории:
- Процедурные: пошаговые рабочие цепочки
- Структурные: специфичные под мой контекст
- Гейты качества: стандарты вывода

**ШАГ 5. Обновлённые инструкции.**
Покажи патченную версию — не длиннее {лимит} символов.

Плейсхолдеры: - {название_проекта} — например "Claude Project для работы с клиентами" - {текущие_инструкции} — твои актуальные инструкции, даже если они короткие и неидеальные - {описание_чем_занимается_проект} — 1–2 предложения про тип задач - {5-10} — количество проб. 5 для быстрого прохода, 10 если инструкции сложные - {лимит} — рекомендую 1000–2000 символов. Длиннее — не лучше

После первой итерации — вставь обновлённые инструкции обратно в шаблон и повтори. 3 итерации обычно достаточно.


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

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

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

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


⚠️

Ограничения

⚠️ Нетривиальная задача: Для простых инструкций ("отвечай кратко") метод избыточен. Probe-and-Refine работает там где есть реальная сложность — многошаговые задачи, специфический контекст, разные типы входящих запросов.

⚠️ Качество проб зависит от описания: Если ты нечётко описал задачу в шаге 1 — модель сгенерирует нерелевантные тест-кейсы и диагностика будет мимо. Придётся уточнять.

⚠️ Инструкции под одну модель: Инструкции, отточенные под Claude, могут работать хуже в ChatGPT и наоборот. Исследование подтвердило: guidance, откалиброванный под одну модель, дестабилизирует другую. Если переключаешься между LLM — запусти итерацию заново.

⚠️ Не панацея для длины: Просто добавить больше текста в инструкции не помогает, а иногда вредит. Ценность Probe-and-Refine — в правильном контенте, не в объёме.


🔗

Ресурсы

Название: Probe-and-Refine Tuning of Repository Guidance for Coding Agents (2026, препринт)

Авторы: Asa Shepard, Jeannie Albrecht — Williams College

Код: github.com/asashepard/probe-and-refine-tuning

Бенчмарк: SWE-bench Verified

Упомянутые смежные работы: Meta Context Engineering (Ye et al., 2026), SWE-ContextBench (Zhu et al., 2026), Self-Refine (Madaan et al., 2023), Reflexion (Shinn et al., 2023)


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

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

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

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

Четыре шага на каждую итерацию. Генерируй 5–10 тест-кейсов по своей задаче. Прогоняй каждый через текущие инструкции — симулируй ответ. Оценивай: СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ, причина — 1–2 предложения. Патчи максимум 5 конкретных мест. Повтори. Контент-анализ 104 правил, добавленных через этот процесс, показал три устойчивых категории: процедурные (47% — "сначала воспроизведи проблему, потом чини"), структурные (30% — конкретные разделы, типы запросов, твой контекст) и гейты качества (23% — "показывай реальный вывод, не придумывай"). Стоп-критерий простой: две итерации без изменений — инструкции готовы.

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

LLM не додумывает — она заполняет. Написал "анализируй тщательно" — модель анализирует тщательно по своему усмотрению. Когда факты противоречат друг другу или запрос нестандартный — инструкции молчат. Модель импровизирует. Одноразовая генерация воспроизводит тот же паттерн: выдаёт советы уровня "проверяй факты" — звучит разумно, но не говорит что именно делать. Каждая итерация Probe-and-Refine сужает пространство трактовки: от общих советов к конкретным операционным правилам. Синтетические провалы вскрывают именно те ситуации, где инструкции не справляются — и заставляют добавить правило под каждую из них.

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

Project Instructions в Claude Projects, кастомные GPT, системные промпты для многошаговых задач. Особенно когда модель "понимает задачу, но делает не то": разные типы входящих запросов, специфический контекст, рабочие цепочки с несколькими этапами. НЕ подходит для простых инструкций — "отвечай кратко" итерировать не нужно. Важный момент: инструкции, отточенные под Claude, могут работать хуже в ChatGPT и наоборот — исследование это прямо подтвердило. Переключаешься между моделями — запускай итерацию заново.

Мини-рецепт

1. Собери материал: вставь в промпт текущие инструкции (даже если они короткие и кривые) и 1–2 предложения о задаче проекта.
2. Запроси итерацию: попроси сгенерировать 5 тест-кейсов, симулировать ответ по текущим инструкциям, оценить СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ.
3. Получи патч: для каждого провала — диагноз чего не хватило и до 5 конкретных правок по трём категориям: процедурные правила, структурные уточнения под твой контекст, гейты качества вывода.
4. Повтори: вставь обновлённые инструкции обратно и запусти следующую итерацию. Три прохода обычно хватает. Если две итерации подряд прошли без изменений — всё, готово.

Примеры

[ПЛОХО] : Напиши хорошие инструкции для анализа клиентских запросов
[ХОРОШО] : У меня есть инструкции для Project: --- Анализируй бриф клиента. Выяви ключевую задачу. Предложи решение. --- Моя задача: анализировать запросы клиентов агентства и готовить коммерческие предложения. Проведи зонд-итерацию: 1. Сгенерируй 5 тест-кейсов — разных по типу задач. 2. Для каждого симулируй ответ по текущим инструкциям. Оцени: СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ. 3. Для ЧАСТИЧНЫЙ и ПРОВАЛ: 1–2 предложения — чего не хватило в инструкциях. 4. Предложи до 5 правок: процедурные (пошаговые цепочки), структурные (под мой контекст), гейты качества (стандарты вывода). 5. Покажи обновлённые инструкции не длиннее 1500 символов.
Источник: Probe-and-Refine Tuning of Repository Guidance for Coding Agents
ArXiv ID: 2606.20512 | Сгенерировано: 2026-06-19 05:25

Проблемы LLM

ПроблемаСутьКак обойти
Общие инструкции могут вредить больше, чем их отсутствиеПишешь инструкции за один заход. Получаешь советы вроде "анализируй тщательно" или "проверяй факты". Звучит разумно. Но модель следует им буквально. Слово "тщательно" интерпретирует по-своему. Часто не так как нужно. Итог: инструкции создают ложную структуру. Модель идёт по ней в тупик — хотя без инструкций просто делала бы по умолчанию. Проблема для любых системных инструкций, где есть специфика задачиНе генерируй инструкции за один проход. Используй цикл: сгенерируй тест-кейсы найди где инструкции проваливаются добавь конкретные правила для этих случаев. 3–5 итераций превращают общие советы в операционные правила

Методы

МетодСуть
Probe-and-Refine — отладка инструкций через синтетические провалыБерёшь текущие инструкции. Просишь модель сгенерировать 5–10 тест-кейсов по твоей задаче. Потом — симулировать выполнение каждого по текущим инструкциям. Оценить: СИЛЬНЫЙ / ЧАСТИЧНЫЙ / ПРОВАЛ. Для провалов — диагноз: чего именно не хватило. Затем — до 5 конкретных правок. Повторяешь 3–5 раз. Стоп: две итерации подряд без изменений. Почему работает: модель хорошо симулирует выполнение по правилам и хорошо диагностирует почему правила не сработали. Она одновременно исполнитель, судья и редактор. Каждая итерация сужает пространство интерпретации — от общих советов к конкретным шагам. Синтаксис запроса: ШАГ 1. Синтетические пробы ШАГ 2. Симуляция ШАГ 3. Диагностика ШАГ 4. Патч ШАГ 5. Обновлённые инструкции (не длиннее {лимит} символов). Когда применять: многошаговые задачи, специфический контекст, разные типы входящих запросов. Когда избыточно: простые инструкции из одной строки

Тезисы

ТезисКомментарий
Эффективные инструкции делятся на три вида: процедурные, структурные, гейты качестваАнализ 104 правок, добавленных через итеративную отладку — три устойчивых типа. Процедурные (47%) — пошаговые цепочки: "сначала воспроизведи ошибку, потом фикси". Структурные (30%) — конкретные ссылки на твой контекст: разделы, типы запросов, специфику задачи. Гейты качества (23%) — стандарты вывода: "показывай реальный результат, не придумывай". Общие советы не попадают ни в одну категорию. Применяй: когда пишешь инструкции с нуля — проверь есть ли все три вида. Если только общие советы — они скорее всего не сработают
📖 Простыми словами

Probe-and-Refine Tuning of Repository Guidance for CodingAgents

arXiv: 2606.20512

Суть метода Probe-and-Refine в том, что нейронки патологически буквально исполняют приказы, но при этом абсолютно не понимают абстракций. Если ты пишешь в инструкции «делай хорошо», модель интерпретирует это как бог на душу положит, обычно скатываясь в унылую посредственность. Чтобы заставить её работать нормально, нужно не подбирать красивые слова, а намеренно бить её по рукам, создавая искусственные провалы. Ты скармливаешь системе сложные задачи, на которых она гарантированно споткнётся, смотришь, где именно она лажает, и точечно «заплавляешь» эти дыры в промпте.

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

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

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

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

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

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

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