3,583 papers
arXiv:2608.08344 75 8 авг. 2026 г. FREE

PRISM: порядок инструкций в промпте может менять точность на 90 процентных пунктов

КЛЮЧЕВАЯ СУТЬ
Шесть одних и тех же инструкций, только в разном порядке — точность прыгает с 6% до 97%. Один и тот же вопрос, одна и та же модель, ничего не менялось кроме последовательности блоков. Принцип из PRISM позволяет находить порядок шагов в промпте, который сам поднимает точность — без единой правки текста инструкций. Модель отвечает раньше, чем у неё появились нужные цифры — если шаг «дай ответ» стоит перед шагом «посчитай», LLM угадывает, а не считает. Худшие промпты в исследовании — все до одного ставили вывод раньше расчёта.
Адаптировать под запрос

TL;DR

Одни и те же шесть инструкций в промпте, переставленные в разном порядке, дают точность от 6% до 97% — на одних и тех же вопросах, с одной и той же моделью. Разница — только порядок блоков "прочитай задачу", "выдели данные", "составь план", "посчитай", "проверь", "дай ответ".

Главная находка простая и болезненная: если инструкция "дай ответ" стоит перед инструкцией "посчитай" — модель отвечает раньше, чем у неё появились нужные цифры. Она угадывает, а не считает. Худшие промпты в исследовании — все до одного ставили ANSWER раньше COMPUTE. Лучшие — наоборот.

Метод, который стоит за этим открытием (PRISM), измеряет "структуру" пространства перестановок через статистику — но это исследовательский инструмент для сложных систем (компиляторы, нейросети). Для читателя чата ценен не сам PRISM, а вывод: расставляй шаги в промпте в порядке "что нужно раньше — идёт раньше", финальный вывод — всегда в конце, после того как все расчёты и проверки уже в тексте.

🔬

Схема метода (упрощённая версия для чата)

ШАГ 1: Разбей промпт на смысловые блоки-инструкции (не абзацы, а логические шаги)
ШАГ 2: Расставь блоки по правилу зависимости → блок, который использует
       результат другого блока, ставь ПОСЛЕ него
ШАГ 3: Финальный вывод/ответ/вердикт — всегда последним блоком
ШАГ 4: Протестируй 2-3 альтернативных порядка на одной задаче → сравни результат

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


🚀

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

Задача: Промпт для оценки бизнес-идеи стартапа — как в "Бизнес-секретах" или питче перед инвестором.

Плохой промпт (вердикт раньше расчётов):

Оцени идею стартапа: [описание].
1. Дай вердикт — стоит ли инвестировать
2. Посчитай юнит-экономику (CAC, LTV, маржа)
3. Сравни с конкурентами на рынке
4. Опиши идею своими словами

Хороший промпт (вердикт после расчётов):

Оцени идею стартапа: [описание].
1. Опиши идею своими словами
2. Сравни с конкурентами на рынке
3. Посчитай юнит-экономику (CAC, LTV, маржа)
4. На основе расчётов выше — дай вердикт: инвестировать или нет

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


🧠

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

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

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

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

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


📋

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

Реши задачу: {задача}

Следуй шагам строго в этом порядке:
1. {шаг, который собирает исходные данные}
2. {шаг, который анализирует/структурирует данные}
3. {шаг, который производит расчёт или рассуждение}
4. {шаг, который проверяет результат предыдущего шага}
5. {финальный вывод — только после того как все расчёты и проверки сделаны}

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

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

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

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

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

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


⚠️

Ограничения

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

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

⚠️ Основной протокол PRISM не работает в чате: измерение "автокорреляции" и "структуры пространства перестановок" из статьи требует кода, точных вычислений и экспериментов с большим числом перестановок. Это инструмент для компиляторов, нейросетевых архитектур и научных пайплайнов — не для промпт-инженеринга вручную. Из чата доступен только упрощённый принцип "тестируй порядок вручную".

⚠️ Эффект измерен на математических задачах: исследование проверяло вывод на GSM8K (школьная математика) и MATH-500. Для творческих, аналитических или неоднозначных задач эффект порядка может проявляться иначе.


🔗

Ресурсы

PRISM: A Predictive Protocol for Permutation Optimization via Landscape Diagnostics. Blessings Mambwe, ML Collective. Код и артефакты: github.com/bleymambwe/PRISM


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

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

Шесть одних и тех же инструкций, только в разном порядке — точность прыгает с 6% до 97%. Один и тот же вопрос, одна и та же модель, ничего не менялось кроме последовательности блоков. Принцип из PRISM позволяет находить порядок шагов в промпте, который сам поднимает точность — без единой правки текста инструкций. Модель отвечает раньше, чем у неё появились нужные цифры — если шаг «дай ответ» стоит перед шагом «посчитай», LLM угадывает, а не считает. Худшие промпты в исследовании — все до одного ставили вывод раньше расчёта.

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

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

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

LLM генерирует ответ слева направо, токен за токеном. Она не видит, что через два пункта будут нужные цифры — работает только с тем, что уже написано к моменту генерации. Просишь вывод раньше данных — модель либо угадывает, либо тащит общие знания вместо конкретных расчётов из твоей задачи. Свежий контекст прямо перед нужным местом в тексте влияет на ответ сильнее, чем то, что было написано десять строк назад. Отсюда и разброс 6%–97% на одном и том же тексте инструкций — переставили блоки, изменили что модель видит перед собой в нужный момент.

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

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

Мини-рецепт

1. Разбей промпт на шаги: не абзацы, а логические блоки — собрать данные, посчитать, проверить, дать вывод.
2. Расставь по зависимости: шаг, который использует результат другого шага, всегда идёт после него.
3. Вывод — в конец: финальный ответ ставь последним пунктом, после всех расчётов и проверок.
4. Проверь на практике: прогони 2-3 варианта порядка на одной задаче, сравни ответы — разница может быть огромной.

Примеры

[ПЛОХО] : Оцени идею стартапа: [описание]. 1. Дай вердикт — стоит ли инвестировать. 2. Посчитай юнит-экономику. 3. Сравни с конкурентами.
[ХОРОШО] : Оцени идею стартапа: [описание]. 1. Опиши идею своими словами. 2. Сравни с конкурентами на рынке. 3. Посчитай юнит-экономику: стоимость привлечения клиента (CAC), пожизненную ценность клиента (LTV), маржу. 4. На основе расчётов выше — дай вердикт: инвестировать или нет.
Источник: PRISM: A Predictive Protocol for Permutation Optimization via Landscape Diagnostics
ArXiv ID: 2608.08344 | Сгенерировано: 2026-08-11 05:45

Проблемы LLM

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

Методы

МетодСуть
Порядок шагов по зависимости данныхРазбей промпт на логические блоки-инструкции (не абзацы, а шаги: собрать данные, посчитать, проверить, дать вывод). Расставь их так: блок, использующий результат другого блока, идёт строго после него. Финальный вывод — всегда последний пункт списка. 1. собери данные 2. проанализируй 3. посчитай 4. проверь 5. дай вывод. Почему работает: модель генерирует ответ токен за токеном и не может "заглянуть вперёд" в промпт — она видит только то, что уже написано до текущего места. Работает для многошаговых промптов с явной зависимостью между шагами. Не работает — если шаги не зависят друг от друга или задача однослойная (эффект порядка исчезает)

Тезисы

ТезисКомментарий
Порядок инструкций и текст инструкций — два независимых рычага точностиПереписывание формулировок инструкций (более чёткие, ясные) и перестановка блоков в промпте влияют на точность отдельно друг от друга. Улучшение текста не убирает вред от неправильного порядка, и наоборот. Работает потому что порядок задаёт что модель видит в контексте на момент генерации, а текст задаёт что она понимает из каждого блока — это разные механизмы влияния. Применяй: если промпт работает плохо, проверяй раздельно и формулировки шагов, и их последовательность — правка одного без другого может не дать эффекта
📖 Простыми словами

PRISM: A Predictive Protocol for Permutation Optimization via Landscape Diagnostics

arXiv: 2608.08344

Суть в том, что нейросети — это не сверхразум, а очень старательные, но ограниченные линейные вычислители. Они не видят твой промпт целиком, как картинку, а жуют его строго по порядку, слово за словом. Если ты просишь модель выдать результат до того, как она успела «переварить» вводные данные или составить план, она начинает гадать на кофейной гуще. Весь этот хаос с точностью, которая скачет от позорных 6% до почти идеальных 97%, завязан на одной простой механике: модель не умеет заглядывать в будущее.

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

Чтобы эта магия сработала, нужно использовать PRISM — протокол, который расставляет блоки инструкций в правильной логической последовательности. Работает это так: сначала заставляем модель «впитать» контекст, потом выделить жесткие данные, следом составить план действий, провести расчеты, перепроверить себя и только в самом финале выдать результат. Разница в эффективности между «сначала посчитай, потом ответь» и «сначала ответь, а потом обоснуй» — это пропасть в 90% точности.

Хотя исследование гоняли на математических задачах, принцип универсален для любого сложного промпта, будь то оценка стартапа для инвестора или написание кода. Если ты просишь нейронку оценить бизнес-идею, но ставишь критерии оценки в самый конец длинного текста, она выдаст тебе водянистую чепуху. Стоит перенести структуру анализа в начало, а команду «вынеси вердикт» в конец — и ты получаешь адекватного аналитика вместо генератора случайных фраз.

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

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

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

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