3,583 papers
arXiv:2610.08405 72 6 окт. 2026 г. FREE

FDPR (Failure-Driven Prompt Refinement): доработка промпта через разбор повторяющихся ошибок

КЛЮЧЕВАЯ СУТЬ
Модель выдала 111 «находок» в коде, а после доработки промпта осталось 26, и ложных среди них не нашли. Метод FDPR позволяет чинить промпт по причинам ошибок, а не гадать, какой совет из интернета сработает на твоей модели. Фишка: группируй ошибки по причине, а не по внешнему виду. Ты разбираешь, какой механизм рассуждения сломался, и чинишь один тип за круг. Итог в статье: 111 → 26 находок, ноль ложных после ручной проверки, охват категорий сохранился.
Адаптировать под запрос
⚡

TL;DR

FDPR — метод доработки промпта по ошибкам, а не по ощущениям. Вы гоняете промпт на наборе примеров и вручную разбираете каждую ошибку: что выдала модель, почему это неверно, какой механизм рассуждения сломался и какая правка в промпте это предотвратит. Ошибки группируются в типы по причине (а не по внешнему виду). Затем за один круг чинится только самый важный тип, и прогон повторяется.

Главная находка: модель выдаёт много «находок», которые держатся на поверхностных признаках. Увидела слово password в названии переменной и объявила уязвимость. Придумала путь данных, которого в коде нет. Сравнение вариантов промпта по общей точности этого не показывает: цифра есть, а почему ошибается — непонятно. Поэтому чужие советы («примеры помогают», «роль помогает») дают противоречивые результаты. Всё зависит от модели и задачи.

Суть метода — цикл из пяти шагов: наблюдение и причина → таксономия и приоритет → правка одной категории → перепроверка → вывод принципов. В статье на задаче поиска уязвимостей в Java-коде число выдаваемых находок упало со 111 до 26. После ручной проверки ложных срабатываний не осталось ни у одной модели, при этом охват категорий уязвимостей сохранился.

🔬

Схема метода

ШАГ 1: Прогнать промпт на наборе примеров → записать каждую ошибку
        (вывод модели + эталон + контекст)
ШАГ 2: Разобрать причину каждой ошибки → 4 вопроса:
        что выдала? почему неверно? какой механизм рассуждения сломался?
        какая правка промпта это предотвратит?
ШАГ 3: Сгруппировать по ПРИЧИНЕ (не по внешнему виду) → таксономия типов ошибок
        Приоритет: частота, цена ошибки, цена проверки, повторяемость,
        насколько ошибка лечится промптом
ШАГ 4: Починить ОДИН главный тип → одна правка промпта → новый прогон
        (каждая правка привязана к типу ошибки)
ШАГ 5: Повторять, пока улучшений нет или остались ошибки, которые промптом
        не лечатся → правки, которые стабильно работали, превратить в принципы
        → «заморозить» промпт и проверить на новых данных

Шаги 1–5 — отдельные запросы и ручная работа. Разбор причин можно отдать самой LLM, но решение «что считать ошибкой» остаётся за человеком.

🚀

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

Задача: Вы руководитель контент-отдела на маркетплейсе (Ozon, Wildberries). Нужен промпт, который помечает заказные отзывы. Первая версия помечает подозрительным всё, где много восклицательных знаков и слов «супер», «рекомендую всем». Живые довольные покупатели попадают под удар. Модерация тонет в ложных срабатываниях.

Промпт (шаг 2–3, разбор ошибок):

Ты помогаешь мне дорабатывать промпт для поиска заказных отзывов.

Ниже — 12 случаев, где промпт ошибся. Для каждого указано: текст отзыва,
что ответила модель, какой ответ верный (по решению модератора).

Для КАЖДОГО случая ответь на 4 вопроса:
1. Что выдала модель?
2. Почему это неверно?
3. Какой механизм рассуждения сломался (например: решила по
   ключевому слову; придумала факт, которого нет в тексте; не учла
   контекст категории товара)?
4. Какая правка в промпте это предотвратила бы?

Затем:
- Сгруппируй случаи в типы ошибок ПО ПРИЧИНЕ (механизму), а не по виду.
- Оцени каждый тип: как часто встречается, чем опасен (блокировка
  честного покупателя дороже пропуска заказного), насколько легко
  проверить вручную, лечится ли это правкой промпта.
- Назови ОДИН тип с наивысшим приоритетом и предложи ОДНУ правку промпта.

[текущий промпт]
[12 случаев]

Результат: Модель выдаст разбор по каждому случаю с четырьмя ответами. Затем покажет таксономию (например, «решение по стилю текста», «выдуманные признаки накрутки»). Потом даст таблицу приоритетов и одну предложенную правку. Эту правку вы вносите в промпт и прогоняете заново. Следующий круг — следующий тип ошибки.

🧠

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

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

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

Как метод это использует. Он заменяет угадывание диагностикой. Группировка по причине превращает россыпь разных ошибок в 3–4 повторяющиеся привычки. Правка одной категории за раз показывает, что именно помогло, и не создаёт новых ошибок.

Рычаги управления: - Размер набора разбора (12 случаев → 30) — больше случаев дают более надёжную таксономию, но разбор дольше. - Критерии приоритета — замените на свои: для юриста важнее цена пропуска, для маркетинга — цена ложной тревоги. - Условие остановки — «нет улучшения» или «остались ошибки, которые промптом не лечатся». Второе тоже результат: так вы находите, что нужен человек или другая модель. - Проверка на свежих данных — после доработки заморозьте промпт и прогоните на примерах, которые не видели при разработке.

📋

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

Шаблон 1. Разбор ошибок (шаги 1–3):


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



{текущий_промпт}

{случай_1: вход | ответ модели | верный ответ | контекст}
{случай_2: ...}
...




Для каждого случая ответь:
1. Что выдала модель?
2. Почему это неверно?
3. Какой механизм рассуждения сломался?
4. Какая правка промпта это предотвратила бы?
Отдельно отметь случаи, где причина НЕ в промпте
(неоднозначные данные, ошибка в эталоне, ограничение модели).



Сгруппируй случаи по механизму ошибки. Дай каждому типу имя
и перечисли номера случаев.



Оцени каждый тип по критериям: {критерии_приоритета}.
Выбери ОДИН тип для следующей правки.



Таблица типов + одна конкретная правка промпта для выбранного типа
(покажи старую и новую формулировку).

Шаблон 2. Какие правки использовали авторы (вид итогового промпта). Финальная версия в статье включала: роль аудитора; требование доказательного рассуждения (вход → путь → итог) до вывода; контрастные примеры «плохо / хорошо»; запрет на выводы без подтверждения; структурированный вывод с уверенностью и цепочкой доказательств. Для своей задачи их можно собрать так:

Ты — {роль}. Прежде чем сообщить о находке, покажи цепочку
доказательств: {шаг_1_откуда_данные} → {шаг_2_как_связано} → {шаг_3_вывод}.
Если цепочку по тексту собрать нельзя — находку не сообщай.

Примеры:
Неверно: {пример_ложной_находки} — потому что {механизм_ошибки}.
Верно: {пример_подтверждённой_находки}.

Формат ответа (JSON): {место, категория, уверенность, цепочка_доказательств}

Что подставлять: {критерии_приоритета} — что для вас дороже: частота, цена ошибки, цена проверки. {роль} и шаги цепочки — ваша задача. Примеры «неверно/верно» берите из реальных ошибок вашего промпта.

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

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

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

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

⚠️

Ограничения

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

⚠️ Нет сравнения с обычной доработкой: авторы не показали, что FDPR лучше, чем просто аккуратно править промпт. Показано, что последовательность правок снизила шум, но вклад самого метода отдельно не измерен.

⚠️ Падение «находок» ≠ рост качества: 111 → 26 — это число отчётов, проверенных вручную. Если делать то же на своей задаче, смотрите ещё и на пропущенные случаи. Иначе промпт станет слишком осторожным.

⚠️ Одна область и небольшая разработочная выборка: метод отлаживали на 13 учебных Java-программах и проверяли на уязвимостях. Перенос на другие задачи авторы называют лишь возможным, они его не проверяли.

⚠️ Локальные модели: тестировали открытые модели среднего размера при температуре 0, не топовые облачные. Привычки ошибок у ChatGPT, Claude и Gemini могут быть другими.

⚠️ Текст статьи неполон: во входных данных обрезан раздел результатов. Итоги внешней проверки на большом наборе (Juliet) в оценке не использованы.

🔍

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

Идея простая: если промпты улучшают на глаз или по общему проценту, то ошибки теряются. Авторы взяли учебное приложение с уязвимостями (13 Java-программ, 10 категорий OWASP) и прогнали через четыре локальные модели: Qwen3-Coder-30B, Qwen3.5-35B, DeepSeek-Coder-6.7B и Llama-3.2-3B. Каждую найденную «уязвимость» проверили вручную: правда ли это, верна ли категория, есть ли доказательство в коде, не выдумана ли цепочка.

Ошибки группировали по механизму. Например, «нашла password в имени переменной» — это переобобщение по шаблону. «Придумала несуществующий путь данных» — выдуманное доказательство. Так получилось четыре версии промпта (v0 → v3). Находок стало: 111 → 49 → 37 → 26.

В базовой версии ни одна модель не покрыла все 10 категорий. Qwen3-Coder нашла 6 из 10, Qwen3.5 — 8, DeepSeek — 0, Llama — 1. После доработки у каждой модели ложных срабатываний не осталось, а вместе модели покрыли все 10 категорий.

Что удивило: последняя правка (v3) убрала искусственные ограничения на список категорий — и результат стал лучше. Жёсткие рамки в промпте тоже могут быть источником ошибок. Ещё часть «промахов» оказалась не ошибкой модели, а следствием смены классификации OWASP: эталон устарел. Вывод для практики: проверяйте не только промпт, но и сам эталон.

Для проверки на новых данных промпт заморозили и прогнали на наборе Juliet (около 40 тысяч программ, 112 типов слабостей) с вычищенными подсказками. Результаты этой части в доступном тексте обрезаны.

💡

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

🔧 Техника: добавить «правило цитаты» → меньше выдуманных находок

Из финального промпта статьи можно взять одно правило и вставить в любой промпт-проверяльщик (договоры, отзывы, резюме, тексты):

Каждое замечание сопровождай дословной цитатой из текста, на которую
оно опирается. Нет цитаты — замечания нет.

🔧 Техника: поручить разбор ошибок отдельному чату

Не смешивайте в одном чате «рабочий» промпт и «разбор его ошибок». Откройте новый чат, вставьте шаблон 1 и 10–15 случаев сбоя. Так модель не защищает собственный ответ.

Экстраполяция: FDPR для файла инструкций агента. Это идея по мотивам статьи, в ней она не проверялась. Если агент (например, Claude Code) стабильно ошибается — лишний рефакторинг, выдуманные функции, — соберите 10 таких случаев и прогоните через шаблон 1. Одну исправляющую правку внесите в CLAUDE.md и посмотрите, ушёл ли именно этот тип ошибки.

🔗

Ресурсы

  • Работа: Learning from Failures: A Failure-Driven Prompt Refinement for LLM-Based Vulnerability Analysis
  • Авторы: Mandana Ghadamian, David Mohaisen — University of Central Florida, Orlando, США
  • Данные: Damn Vulnerable Java Application (DVJA), Juliet Test Suite v1.3 (Java)
  • Модели: Qwen3-Coder-30B, Qwen3.5-35B, DeepSeek-Coder-6.7B, Llama-3.2-3B (через Ollama)

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

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

Модель выдала 111 «находок» в коде, а после доработки промпта осталось 26, и ложных среди них не нашли. Метод FDPR позволяет чинить промпт по причинам ошибок, а не гадать, какой совет из интернета сработает на твоей модели. Фишка: группируй ошибки по причине, а не по внешнему виду. Ты разбираешь, какой механизм рассуждения сломался, и чинишь один тип за круг. Итог в статье: 111 → 26 находок, ноль ложных после ручной проверки, охват категорий сохранился.

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

Это цикл из пяти шагов, и почти весь он ручной. 1. Прогнал промпт на примерах, записал каждую ошибку: ответ модели, эталон, контекст. 2. Ответил по каждой ошибке на 4 вопроса: что выдала, почему неверно, какой механизм рассуждения сломался, какая правка это предотвратит. 3. Сгруппировал ошибки по причине. Выбрал один главный тип: он частый, дорогой и лечится промптом. 4. Внёс одну правку. Прогнал заново. 5. Повторяй, пока есть улучшения. Правки, которые держатся, превращай в принципы. Потом заморозь промпт и проверь на новых данных. Одна правка за круг — и ты точно знаешь, что именно помогло. Это как чинить машину по одной детали, а не менять всё сразу и гадать, что сработало.

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

Без требования доказательств модель цепляется за самый простой признак. Увидела слово password в названии переменной — объявила уязвимость. Придумала путь данных, которого в коде нет. Общая точность этого не покажет: цифра есть, а причина ошибки не видна. Поэтому советы «примеры помогают» и «роль помогает» то работают, то вредят. Всё зависит от модели и задачи. Модель хорошо слушается, когда ей называют конкретный механизм ошибки. «Отметка без цитаты из текста недопустима» работает лучше, чем «будь внимательнее». Группировка по причине превращает россыпь разных ошибок в 3-4 повторяющиеся привычки, а привычку чинить проще, чем каждый случай отдельно. Честно про слабые места. Авторы не сравнили FDPR с обычной аккуратной правкой промпта. Вклад самого метода отдельно не измерен. Проверяли на 13 учебных программах на Java и на открытых моделях среднего размера.

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

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

Мини-рецепт

1. Собери ошибки: прогони промпт на 12-30 примерах с известным ответом. Выпиши те, где модель промахнулась: вход, её ответ, верный ответ.
2. Разбери причины: отдай ошибки модели с четырьмя вопросами. Что выдала? Почему неверно? Какой механизм сломался? Какая правка поможет? Решение «что считать ошибкой» оставь за собой.
3. Отсей чужое: попроси отметить случаи, где виноват не промпт. Это неясные данные, ошибка в эталоне или потолок модели.
4. Сгруппируй по причине: дай каждому типу имя и список номеров случаев.
5. Выбери критерии: что дороже, ложная тревога или пропуск? Для юриста важнее пропуск, для маркетинга ложная тревога.
6. Почини один тип: одна правка, новый прогон на тех же примерах. Сравни до и после.
7. Крути круги: остановись, когда улучшений нет. Остались ошибки, которые промптом не лечатся? Это тоже результат: нужен человек или другая модель.
8. Заморозь и проверь: прогони финальный промпт на примерах, которых не видел при доработке.

Готовый шаблон для шагов 2-4:
Ты — аналитик качества промптов. Найди повторяющиеся причины ошибок, а не пересказывай случаи.
{текущий_промпт}
{случай_1: вход | ответ модели | верный ответ | контекст} ...
Для каждого случая ответь: 1. Что выдала модель? 2. Почему неверно? 3. Какой механизм рассуждения сломался? 4. Какая правка промпта это предотвратила бы? Отдельно отметь случаи, где причина не в промпте. Сгруппируй случаи по механизму ошибки, дай типам имена. Оцени типы по критериям: {критерии_приоритета}. Выбери ОДИН тип и покажи старую и новую формулировку промпта.


Как выглядел итоговый промпт у авторов, собери по аналогии:
Ты — {роль}. Прежде чем сообщить о находке, покажи цепочку доказательств: {откуда_данные} → {как_связано} → {вывод}. Если цепочку по тексту собрать нельзя — находку не сообщай. Неверно: {пример_ложной_находки} — потому что {механизм_ошибки}. Верно: {пример_подтверждённой_находки}. Формат ответа (JSON): {место, категория, уверенность, цепочка_доказательств}

Примеры «неверно/верно» бери из реальных ошибок своего промпта, не выдумывай.

Примеры

[ПЛОХО] : Улучши промпт для поиска заказных отзывов, он слишком много блокирует честных покупателей
[ХОРОШО] : Ты помогаешь мне дорабатывать промпт для поиска заказных отзывов. Ниже 12 случаев, где он ошибся: текст отзыва, ответ модели, верный ответ по решению модератора. Для каждого случая ответь: что выдала модель, почему это неверно, какой механизм рассуждения сломался (решила по ключевому слову, придумала факт, не учла категорию товара), какая правка это предотвратит. Сгруппируй случаи по механизму, а не по виду. Блокировка честного покупателя дороже пропуска заказного. Выбери ОДИН тип с наивысшим приоритетом и предложи ОДНУ правку. [текущий промпт] [12 случаев] Результат: модель покажет, что половина ошибок идёт по одной привычке, «решение по стилю текста». Правка одна: Отзыв заказной, только если есть конкретный признак накрутки с цитатой из текста. Восклицательные знаки и слова «супер», «рекомендую» признаком не считаются. Прогнал заново и перешёл к следующему типу ошибки.
Источник:
ArXiv ID: 2610.08405 | Сгенерировано: 2026-10-07 05:50

Проблемы LLM

ПроблемаСутьКак обойти
Модель решает по поверхностному признаку и додумывает подтверждениеЗадача: найти в тексте или коде что-то подозрительное. Модель видит знакомое слово, стиль или шаблон. Сразу объявляет находку. Иногда придумывает связь, которой в тексте нет. Выдача выглядит убедительно, но много ложных срабатываний. Общая точность не показывает, из-за какой привычки это случилось. Одной фразой «будь внимательнее» это не лечитсяТребуй цепочку доказательств до вывода. В запросе пиши: «Прежде чем сообщить находку, покажи цепочку: откуда данные → как связаны → вывод. Если цепочку по тексту собрать нельзя, находку не сообщай». Добавь пары «неверно / верно» с объяснением механизма ошибки. Просто помечать находки по ключевому слову запрещай прямо

Методы

МетодСуть
Доработка запроса по причинам ошибок, по одному типу за кругЧто делать. 1) Прогони запрос на 10–30 примерах с известным верным ответом. Запиши каждую ошибку: вход, ответ модели, эталон. 2) По каждой ошибке ответь на 4 вопроса: что выдала модель, почему это неверно, какой механизм рассуждения сломался («решила по слову», «выдумала факт», «не учла контекст»), какая правка запроса это предотвратит. Этот разбор можно отдать самой LLM. Что считать ошибкой, решаешь ты. 3) Сгруппируй ошибки по причине, а не по виду. Получится 3–4 повторяющиеся привычки. 4) Оцени каждый тип: как часто встречается, сколько стоит ошибка, как трудно проверить, лечится ли запросом. 5) Почини один главный тип одной правкой. Прогони заново. Повторяй. Почему работает: общая точность говорит «хуже» или «лучше», но не говорит почему. Причина превращает россыпь ошибок в несколько привычек. Одна правка за круг показывает, что именно помогло, и не плодит новые ошибки. Остановка: улучшений нет, или остались ошибки, которые запросом не лечатся. Это тоже результат: нужен человек или другая модель. В конце заморозь запрос и проверь на новых примерах. Когда да: есть эталон и время на ручной разбор. Подходит для классификации, поиска проблем, проверки, извлечения. Когда нет: нет верных ответов или набора примеров. Следи за пропусками: если шум упал, проверь, не стал ли запрос слишком осторожным и не режет ли он нужные находки

Тезисы

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

Learning from Failures: A Failure-DrivenPromptRefinement forLLM-Based Vulnerability Analysis

arXiv: 2610.08405

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

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

Именно так работает метод FDPR (Failure-Driven Prompt Refinement): ты прогоняешь базу примеров и вручную разбираешь факапы. Ошибки группируют не по внешним признакам, а строго по первопричине сбоя. Главное правило: за один цикл ты устраняешь ровно один критический тип поломки. Ты не переписываешь весь текст сразу, а точечно вправляешь модели мозги жестким ограничением именно под этот баг.

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

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

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

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

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