TL;DR
Исследователи посчитали, сколько одновременных требований может выдержать LLM в одном промпте — и цифра неутешительная: 5-6 требований это потолок для надёжной работы, а для большинства моделей потолок — 2-4. При этом каждое отдельное требование модель выполняет неплохо (скажем, 40% успеха на восьмом требовании), но шанс выполнить все требования сразу падает почти до нуля — потому что это как бросить 8 монеток и просить, чтобы все выпали орлом.
Главная находка: провалы требований почти не связаны друг с другом. Модель не путает одно требование с другим — она просто независимо проваливает каждое с некоторой вероятностью, и эти вероятности перемножаются. Из-за этого нельзя схитрить, переставив требования местами или подобрав "удачную" комбинацию — коллапс неизбежен, если требований много. Единственное исключение — требования, которые "читают" один и тот же кусок текста (например, число предложений): если модель один раз ошиблась со счётом предложений, она автоматически провалит все требования, завязанные на этот счёт.
Метод исследования простой: они проверяли деструктивно — накидывали от 1 до 12 требований в один промпт (не изменяй буквы "е", ровно 3 абзаца, используй слова X/Y/Z и т.д.) и смотрели, что выживает. Оказалось, что требования на удержание в голове (считать слова, следить за форматом по ходу генерации) деградируют в 2 раза быстрее, чем требования на бинарное решение (использовать/не использовать слово). Практический вывод: если тебе нужна надёжность — дели требования на несколько запросов, не пытайся впихнуть 8 условий в один промпт.
Схема метода (это не техника, а диагностика — но из неё вытекает практика)
НАБЛЮДЕНИЕ 1: Каждое требование по отдельности → модель выполняет с вероятностью ~40-70%
НАБЛЮДЕНИЕ 2: Вероятности почти независимы → шанс выполнить ВСЕ = произведение всех вероятностей
НАБЛЮДЕНИЕ 3: При k=8 требований → шанс успеха на всех сразу падает до 5.7%, хотя каждое отдельное — 41%
ВЫВОД: чем больше требований в одном промпте — тем экспоненциально ниже шанс, что все выполнены
Пример применения
Задача: Ты просишь Claude/ChatGPT написать пост для соцсетей с кучей требований одновременно.
Промпт (как делают почти все — и почему это ломается):
Напиши пост про запуск нового продукта.
Требования:
- Ровно 3 абзаца
- Не больше 120 слов
- Используй слова "инновация", "команда", "рынок"
- Без восклицательных знаков
- Тон — уверенный, но не хвастливый
- Заверши призывом к действию
- Первое предложение — вопрос
Результат: Модель, скорее всего, нарушит хотя бы 1-2 требования — не заметит сама. Она может дать 4 абзаца вместо 3, или превысить лимит слов на 15%, или забыть одно из трёх ключевых слов. При этом каждое требование по отдельности она "умеет" выполнять — просто вероятности не складываются, а перемножаются, и семь требований — это уже за порогом надёжности.
Что делать вместо этого: Разбей на 2 запроса. Сначала — контент и смысл (тон, ключевые слова, призыв к действию). Потом — отдельным запросом попроси проверить и подрезать под формальные рамки (3 абзаца, 120 слов, без восклицательных знаков). Формальные, счётные требования — самые хрупкие, их лучше проверять отдельно, а не диктовать заранее.
Почему это работает
Модель не "видит" промпт целиком как чек-лист, который держит в голове всю генерацию. Она генерирует текст последовательно, и каждое требование, которое нужно удерживать в процессе (считать слова, следить за форматом), конкурирует за внимание с остальными такими же требованиями. Бинарные решения (использовать слово или нет) — это как галочка, которую можно поставить один раз и забыть. Счётчики — это то, что нужно помнить всю дорогу, и именно они ломаются первыми.
Ключевой рычаг, который вытекает из статьи: дели требования по типу. Счётные и структурные требования (число абзацев, слов, предложений) — выноси в отдельный проверочный запрос. Смысловые и бинарные требования (тон, ключевые слова, наличие/отсутствие чего-то) — можно смело комбинировать в одном промпте, они деградируют вдвое медленнее.
Ещё один рычаг: если несколько твоих требований читают один и тот же кусок текста (например, "ровно 5 предложений" и "каждое предложение начинается с глагола" — оба зависят от того, как модель разбила текст на предложения), провал одного почти гарантированно тащит за собой провал другого. Отслеживай такие связки и проверяй их вместе, отдельно от остальных требований.
Шаблон промпта
Это не техника генерации, а диагностический протокол, который можно применить к своему промпту вручную:
У меня есть промпт с несколькими требованиями:
{вставь список требований}
Разбей их на две группы:
1. "Счётные/структурные" — то, что нужно удерживать по ходу генерации
(количество слов, абзацев, предложений, порядок, формат)
2. "Смысловые/бинарные" — то, что можно решить одним махом
(использовать слово, тон, запрет темы, включить/исключить элемент)
Для группы 1 предложи, как проверить и исправить результат отдельным запросом после генерации.
Для группы 2 — оставь всё в одном промпте.
🚀 Быстрый старт — вставь в чат:
Вот мой промпт с требованиями: {вставь свой промпт}.
Раздели требования на "счётные/структурные" (число слов, абзацев, порядок)
и "смысловые/бинарные" (тон, ключевые слова, запреты).
Предложи, как разбить это на 2 запроса: сначала контент, потом проверка формальных рамок.
LLM разберёт твой список требований и покажет, какие из них — самые хрупкие (обычно это счётчики), чтобы ты знал, за какими нужно перепроверять результат вручную или отдельным запросом.
Ограничения
⚠️ Порог начинается раньше, чем кажется: уже на 5-6 одновременных требованиях надёжность выполнения "всё сразу" резко падает — это не гипотетический край, а реальный потолок для большинства моделей уже сегодня.
⚠️ Нет "правильного порядка" требований: переставлять требования местами, комбинировать их по-разному — не помогает. Слабая связь между провалами означает, что нет "выигрышной комбинации", которую можно подобрать.
⚠️ Самокоррекция почти не спасает: попросить модель перепроверить себя или сгенерировать 5 вариантов и выбрать лучший — сдвигает порог лишь на 1-2 требования, не больше. Это не решение, а костыль.
⚠️ Планирование заранее не помогает совсем: если попросить модель сначала расписать план, а потом писать текст — это вообще не меняет порог коллапса. Проблема не в отсутствии плана, а в удержании множества условий одновременно.
Как исследовали
Исследователи создали автоматическую систему проверки — 36 типов требований (не превышай число букв, точное число абзацев, включи такие-то слова и т.д.), каждое проверялось строгим алгоритмом, без участия LLM-судьи (это важно: судья сам ошибается на сложных комбинациях, и это искажало бы результат).
Они прогнали 15 моделей (GPT, Claude, Gemini, Llama, Qwen, DeepSeek, Kimi, Grok) через промпты с числом требований от 1 до 12 — почти 370 000 отдельных проверок. Дизайн был честным: контролировали, чтобы на высоких k не подсовывались специально более сложные требования — сложность требований оставалась одинаковой на всех уровнях, проверили статистически.
Самое удивительное — провалы требований оказались почти независимыми друг от друга. Исследователи ожидали найти "конфликтующие пары" требований, которые мешают друг другу — но нашли только слабую связь, и то через общий кусок текста (если модель неправильно посчитала предложения, она провалит все требования, завязанные на подсчёт предложений), а не через настоящую "путаницу" между смыслами требований. Это значит: коллапс — это чистая математика вероятностей, а не хитрая психология модели.