Цепочки промптов

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

Что такое цепочка

Цепочка — это несколько вызовов модели, где результат одного становится входом следующего. В чате это выглядит естественно: вы получили ответ и пишете «а теперь проверь его». В коде это список сообщений, который вы наращиваете: вопрос → ответ модели → новый вопрос.

Зачем разбивать, если можно попросить всё сразу? Три причины. Промежуточный результат можно посмотреть и проверить, прежде чем идти дальше. Каждый шаг получает короткий и ясный промпт вместо одного огромного. И на каждом шаге можно ветвиться: если проверка нашла ошибки — править, если нет — идти дальше.

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

Самопроверка

Пример из туториала: «назови десять слов, оканчивающихся на „ab“». Модель прошлого поколения выдавала список, в котором пара «слов» была выдумана. Следующее сообщение — «найди замену всем ненастоящим словам» — исправляло список.

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

Это общее правило для любой проверки: формулируйте её так, чтобы «всё в порядке» был допустимым ответом. «Проверь требования на противоречия; если противоречий нет, напиши „противоречий не найдено“» — а не «найди противоречия в требованиях».

Черновик, проверка, правка

Самая частая цепочка в работе — три шага.

Первый: черновик. «Напиши описание релиза по списку изменений».

Второй: проверка по критериям. «Проверь описание релиза по чек-листу: каждое изменение из списка упомянуто; нет технического жаргона; нет обещаний, которых нет в списке. Для каждого пункта — выполнен или нет и почему».

Третий: правка. «Исправь описание с учётом замечаний. Что было в порядке — не трогай».

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

Передача результата дальше

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

Наш пример. Шаг 1: из длинного созвона с клиентом (расшифровки) выписать все договорённости в <agreements>. Шаг 2: по списку договорённостей составить задачи для трекера в JSON. Шаг 3: по задачам написать письмо клиенту с подтверждением. Три коротких промпта, каждый со своим форматом на выходе, и на каждом этапе можно проверить: не потерялась ли договорённость, не появилась ли лишняя задача.

Здесь пригодятся теги и формат из прошлых уроков: если шаг 1 отдал результат в <agreements>, шаг 2 берёт ровно это и ничего больше.

Как это выглядит в коде

Через API цепочка — это список сообщений, который растёт. Ответ модели добавляется как ход ассистента, следом — новый ход пользователя:

import anthropic

client = anthropic.Anthropic()
MODEL = "claude-opus-5"

def ask(messages):
    response = client.messages.create(
        model=MODEL, max_tokens=1500, messages=messages
    )
    return response.content[0].text

messages = [{"role": "user", "content":
    "Выпиши из расшифровки все договорённости с клиентом "
    "в теге <agreements>, по одной на строку.\n\n<transcript>\n…\n</transcript>"}]
agreements = ask(messages)

messages += [
    {"role": "assistant", "content": agreements},
    {"role": "user", "content":
        "По каждой договорённости из <agreements> составь задачу для трекера. "
        "Верни только JSON-массив объектов с полями title, description, owner. "
        "Если договорённость не требует задачи, пропусти её."},
]
tasks = ask(messages)
print(tasks)

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

Для тех, кто не пишет код: концепция та же, что в чате. Разница в том, что программа делает шаги автоматически, а вы задаёте промпты для каждого шага один раз.

Когда цепочка не нужна

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