3,583 papers
arXiv:2604.25650 70 28 апр. 2026 г. FREE

Schema-First Staged Prompting: генерация структурированных сценариев от абстрактных целей к конкретным планам

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

TL;DR

Schema-First Staged Prompting — техника построения промптов, где каждый запрос содержит явную схему желаемого вывода, а сложная задача разбивается на уровни абстракции: сначала цели → потом планы → потом исполнение. На каждом уровне человек проверяет результат перед переходом к следующему.

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

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


🔬

Схема метода

ШАГ 1 (один промпт): Извлечь ограничения из документа
→ Вывод: JSON со списком переменных, их диапазонами, единицами

ШАГ 2 (один промпт): Сгенерировать абстрактные цели в формате Given-When-Then
→ Вывод: JSON с целями в формате {given, when, then, rationale}
→ Человек проверяет: удаляет нереалистичные цели

ШАГ 3 (один промпт): Превратить каждую цель в конкретный план
→ Вывод: JSON с числовыми параметрами и условиями проверки
→ Человек проверяет: корректирует нереалистичные числа

ШАГ 4: Исполнение (уже вне чата — требует код/инфраструктуру)

Шаги 1–3 — отдельные запросы. Каждый следующий промпт получает вывод предыдущего как входные данные.


🚀

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

Задача: Нужно систематически проверить новый B2B SaaS-продукт — систему автоматизации закупок для малого бизнеса. Есть только описание функциональности и список параметров. Надо сгенерировать сценарии использования для пользовательского тестирования.

Промпт (Шаг 1 — извлечь ограничения):

1. Роль:
Ты — эксперт по анализу требований к продукту.

2. Задача:
Из документа ниже извлеки все входные и выходные параметры системы,
их допустимые диапазоны и ограничения.

3. Правила:
- Используй только то, что явно указано в документе
- Если диапазон не указан — поставь null
- Не придумывай параметры, которых нет в тексте

4. Строгая схема вывода:
Верни ТОЛЬКО JSON в таком формате:
{
  "inputs": [
    {"name": "...", "type": "...", "min": ..., "max": ..., "description": "..."}
  ],
  "outputs": [
    {"name": "...", "type": "...", "description": "..."}
  ]
}

5. Правило вывода:
Только JSON — никакого текста до или после.

6. Документ:
{описание_продукта}

Промпт (Шаг 2 — сгенерировать сценарии):

1. Роль:
Ты — QA-специалист, планирующий сценарии для системы {название_системы}.

2. Входные ограничения (используй ТОЛЬКО имена из этого списка):
{json_из_шага_1}

3. Задача:
Сгенерируй набор сценариев в формате Given-When-Then.
Каждый сценарий: что есть изначально (given),
что меняется (when), что ожидаем (then).

4. Правила:
- НЕ используй конкретные числа — только качественные описания
- НЕ придумывай параметры вне списка выше
- Каждый then — ОДНО конкретное ожидаемое поведение

5. Строгая схема вывода:
{
  "scenarios": [
    {
      "id": "S001",
      "given": "...",
      "when": "...",
      "then": ["...", "..."],
      "rationale": "Краткое обоснование"
    }
  ]
}

6. Правило вывода:
Только JSON, без пояснений.

Результат:

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


🧠

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

Слабость LLM: Модель не знает, что "правильный" формат вывода — это именно тот, который нужен тебе. Без явной схемы она генерирует то, что встречала чаще всего в обучении. Результат непредсказуем по структуре.

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

Как метод использует это: Schema-first вшивает строгий шаблон прямо в промпт. Дополнительно — правило "Верни ТОЛЬКО JSON" убирает обёртку в виде комментариев и объяснений. Staged generation добавляет второй слой надёжности: каждый промпт работает с небольшим, уже проверенным контекстом из предыдущего шага — это снижает накопление ошибок.

Рычаги управления: - Секция "Правила" — добавляй запреты под свою задачу: "НЕ изменяй фиксированные параметры", "НЕ придумывай данные вне списка" - Уровни абстракции — можно убрать один уровень (сразу цели → конкретные планы), если задача проще - Секция "Success criteria" — добавь явные критерии качественного ответа, и модель будет самопроверяться - Few-shot exemplars — 1–2 примера правильно заполненной схемы сильно повышают точность структуры


📋

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

1. Роль:
Ты — {специализация_эксперта} для системы/задачи "{название}".

2. Контекст:
{описание_системы_или_документ}

3. Ограничения (используй ТОЛЬКО имена из этого списка):
{список_параметров_или_переменных}

4. Задача:
{что_нужно_сгенерировать} в формате {структура}.
Каждый элемент должен содержать: {список_обязательных_полей}.

5. Строгие правила:
- НЕ используй имена/значения вне списка ограничений
- НЕ включай числа там, где требуется качественное описание
- Каждый {элемент} = ровно {одно_условие_или_действие}

6. Строгая схема вывода:
{json_схема_с_точными_именами_полей}

7. Правило вывода:
Верни ТОЛЬКО JSON-объект, без пояснений и комментариев.

8. Примеры (1-2 заполненных элемента правильной структуры):
{few_shot_пример}

Что подставлять: - {специализация_эксперта} — конкретная роль: "эксперт по требованиям", "QA-инженер", "аналитик данных" - {список_параметров_или_переменных} — вывод предыдущего шага или явный список допустимых значений - {json_схема} — точная структура с именами полей, типами, допустимыми значениями - {few_shot_пример} — 1–2 примера правильно заполненной схемы


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

Вот шаблон Schema-First Staged Prompting. 
Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

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

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


⚠️

Ограничения

⚠️ Требует инфраструктуры для финального шага: Генерация целей и планов в чате работает. Автоматическое исполнение сценариев и проверка результатов — только с кодом.

⚠️ Схему нужно проектировать заранее: Если не знаешь, какие поля нужны — сначала поговори с LLM в свободном формате, выясни структуру, потом переходи к schema-first.

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

⚠️ Температура — только через API: Совет из статьи "выше температура для целей, ниже для планов" в обычном чате ChatGPT/Claude не применишь напрямую. Компенсируй через инструкции: "Генерируй разнообразные, нестандартные варианты" для дивергентной фазы.


🔗

Ресурсы

Using Large Language Models for Black-Box Testing of FMU-Based Simulations Abdullah Mughees, Gaadha Sudheerbabu, Tanwir Ahmad, Dragos Truscan (Åbo Akademi University, Finland), Mikael Manngård (Novia University of Applied Sciences, Finland), Kristian Klemets (University of Turku, Finland)

Принято на European Control Conference (ECC) 2026, Рейкьявик.

Связанные техники: Given-When-Then (Gherkin), Chain-of-Thought, Few-shot prompting, Schema-first prompting.


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

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

'Придумай структуру и заполни' против 'заполни вот эту структуру' — для LLM это принципиально разные задачи. В первом случае модель лажает: выдаёт произвольный формат, изобретает несуществующие поля, игнорирует ограничения. Метод Schema-First Staged Prompting позволяет получать структурированный вывод нужного формата — без выдуманных переменных и сюрпризов на выходе. Фишка: точная JSON-схема вшивается прямо в промпт — модель не угадывает нужный формат, а заполняет готовый шаблон. Сложная задача разбивается на уровни: сначала извлечь ограничения из документа, потом сгенерировать абстрактные цели, потом превратить в конкретные планы. Каждый шаг — отдельный промпт, отдельная схема, человеческая проверка перед следующим шагом.

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

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

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

LLM обучена на огромном количестве структурированных данных. Заполнять готовый шаблон — она умеет. Угадывать нужный тебе формат — нет. Без схемы модель генерирует то, что встречала чаще всего в обучении. Результат непредсказуем по структуре. Со схемой задача упрощается до заполнения паттерна — того, что LLM делает лучше всего. Честно: schema-first и few-shot — не новые техники. Новое здесь — конкретная комбинация с явными запретами-ограничениями и стадийным ревью. Именно запреты ('НЕ используй', 'НЕ придумывай') отличают этот подход от обычного структурированного промптинга.

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

Для любой задачи структурированной генерации — когда нужен предсказуемый формат вывода. Анализ документов → извлечение параметров в JSON. Тест-сценарии → Given-When-Then с конкретными полями. Контент-планы, требования к продукту, анализ конкурентов — всё, где нужен конкретный формат, а не 'как модель решит'. НЕ подходит в двух случаях. Первый: нужен свободный творческий текст — схема его убьёт. Второй: ты ещё не знаешь нужную структуру — сначала поговори с моделью в свободном режиме, выясни что нужно, потом переходи к schema-first. Без заранее спроектированной схемы метод не работает.

Мини-рецепт

1. Спроектируй схему заранее: реши, какие поля нужны на выходе. Запиши 1-2 примера правильно заполненной структуры — они войдут в промпт как образцы.

2. Строй каждый промпт по 7 секциям:
— Роль (конкретная специализация: 'QA-специалист', 'аналитик требований')
— Задача (что сгенерировать)
— Критерии качества (что считать хорошим результатом)
— Схема вывода (точный JSON с именами полей)
— Правила (запреты: 'НЕ используй значения вне списка ниже')
— Примеры (1-2 правильно заполненных элемента)
— Правило вывода ('Верни ТОЛЬКО JSON, без пояснений')

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

4. Проверяй вывод каждого шага перед передачей следующему. Удали нереалистичные элементы. Метод рассчитан на твоё участие — без ревью ошибки накапливаются.

5. Добавляй запреты явно под свою задачу: 'НЕ изменяй фиксированные параметры', 'НЕ придумывай поля, которых нет в схеме', 'НЕ используй числа там, где нужно качественное описание'.

Примеры

[ПЛОХО] : Составь план тестирования системы автоматизации закупок для малого бизнеса
[ХОРОШО] : Роль: ты QA-специалист, планирующий сценарии для системы автоматизации закупок. Ограничения — используй ТОЛЬКО имена из этого списка: {json с параметрами из предыдущего шага} Задача: сгенерируй сценарии в формате Given-When-Then. Given — что есть изначально. When — что меняется. Then — что ожидаем. Правила: — НЕ используй конкретные числа, только качественные описания — НЕ придумывай параметры вне списка ограничений выше — Каждый Then — одно конкретное ожидаемое поведение Схема вывода: {"scenarios": [{"id": "S001", "given": "...", "when": "...", "then": ["..."], "rationale": "..."}]} Пример правильно заполненного элемента: {"id": "S001", "given": "поставщик активен, лимит закупки не исчерпан", "when": "пользователь создаёт заявку на максимальную сумму", "then": ["заявка принята", "уведомление отправлено руководителю"], "rationale": "проверяем граничное значение лимита"} Верни ТОЛЬКО JSON, без пояснений.
Источник: Using Large Language Models for Black-Box Testing of FMU-Based Simulations
ArXiv ID: 2604.25650 | Сгенерировано: 2026-04-29 05:28

Проблемы LLM

ПроблемаСутьКак обойти
Без схемы модель сама выбирает формат выводаПросишь сгенерировать структурированный контент — планы, сценарии, требования. Модель выбирает формат сама. Каждый раз разный. Поля выдуманные. Одни есть, других нет. Ревью занимает время. Парсить программно невозможно.Вшей точную схему прямо в промпт. Укажи все поля, их типы, допустимые значения. Добавь правило: Верни ТОЛЬКО JSON, без пояснений. Модель заполняет твой шаблон, а не изобретает свой

Методы

МетодСуть
Схема вывода в промпте — предсказуемый форматВшей точный шаблон прямо в запрос. JSON с именами полей, типами, допустимыми значениями. Добавь явный список допустимых значений и запрет: НЕ используй имена вне этого списка. Добавь 1–2 примера правильно заполненного шаблона. Почему работает: задача меняется с "придумай формат и заполни" на "заполни вот этот формат". Первая — сложнее для модели. Вторая — предсказуема. Когда: любая задача где нужен конкретный формат вывода
Поэтапная генерация с ревью — разбивка на уровни абстракцииСложную задачу бьёшь на отдельные шаги: собрать ограничения абстрактные цели конкретные планы. Каждый шаг — отдельный промпт. Вывод предыдущего шага идёт входом в следующий. Между шагами — ты смотришь результат и удаляешь ошибки. Почему работает: каждый промпт работает с небольшим, уже проверенным контекстом. Ошибки первого шага не множатся на втором. Применяй: генерация требований, контент-планы, сценарии, анализы
📖 Простыми словами

UsingLargeLanguageModelsfor Black-Box Testing of FMU-Based Simulations

arXiv: 2604.25650

Суть Schema-First Staged Prompting в том, что нейронки — это не всезнающие оракулы, а скорее талантливые, но крайне рассеянные исполнители. Если ты просишь их сделать сложную работу за один присест, они начинают импровизировать, путать структуру и выдавать кашу. Метод решает это через жесткую дисциплину: мы не просто даем задачу, а сначала скармливаем модели строгую схему ответа и заставляем ее двигаться по этапам — от общей стратегии к детальному плану и только потом к реализации. Это превращает хаотичный поток сознания в предсказуемый конвейер.

Это как строить дом с бригадой, которая видит тебя впервые. Ты не говоришь им: "Сделайте красиво к четвергу". Вместо этого ты сначала утверждаешь чертеж фундамента, потом проект стен, и только когда каждый этап принят, разрешаешь класть кирпич. Если пропустить схему и этапы, ты получишь туалет посреди гостиной, потому что строитель так художественно увидел. В IT это называется галлюцинациями, а в жизни — выброшенными деньгами.

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

Хотя метод тестировали на сложных симуляциях (FMU), принцип универсален. Его можно и нужно втыкать везде: от написания маркетинговых стратегий до разработки софта. Везде, где есть риск, что нейронка "улетит" в фантазии или выдаст не тот формат данных, поэтапное проектирование спасает ситуацию. Это переход от наивного чата с ботом к промышленному процессу, где результат на 100% соответствует ТЗ.

Короче: хватит надеяться на магию одного промпта — это путь в никуда. Используй Schema-First Staged Prompting, чтобы загнать креатив нейронки в жесткие рамки структуры. Разбивай задачу на уровни, требуй соблюдения схемы на каждом шаге и проверяй промежуточные итоги. Только так можно получить стабильный результат, который не стыдно показать заказчику или запихнуть в продакшн. Кто продолжает слать "простыни" текста без структуры, тот просто тратит токены впустую.

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

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

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