By Blip in AI — 14 июля 2026

Как работает prompting цепочки рассуждений (Chain-of-Thought, CoT)?

Полный перевод статьи Outcome School о том, как работает Chain-of-Thought prompting, чем отличаются zero-shot и few-shot CoT и где этот подход полезен.

Оригинал: Outcome School. Пост-источник в X: Amit Shekhar. Автор: Amit Shekhar / Outcome School. Перевод на русский.

В этой статье разберём, как работает Chain-of-Thought (CoT) prompting — prompting с цепочкой рассуждений. Также посмотрим, почему модель, которая сразу прыгает к ответу, часто ошибается; как пошаговое рассуждение помогает это исправить; чем отличаются zero-shot и few-shot CoT; и где эта техника действительно полезна.

Мы рассмотрим:

что такое prompt;
что такое LLM;
проблему: когда модель сразу прыгает к ответу;
что такое Chain-of-Thought (CoT) prompting;
простой пример без CoT и с CoT;
Zero-shot CoT и Few-shot CoT;
пошаговый разбор цепочки рассуждений;
почему Chain-of-Thought prompting работает;
где Chain-of-Thought prompting полезен;
о чём важно помнить.

Я — Амит Шекхар, основатель Outcome School. Я обучал и менторил многих разработчиков: их работа помогала получать высокооплачиваемые позиции в IT, решать уникальные задачи технологических компаний и создавать open-source библиотеки, которыми пользуются крупные компании. Мне нравится делиться знаниями через open source, статьи и видео.

В Outcome School я преподаю AI and Machine Learning.

Начнём.

Что такое prompt?

Прежде чем переходить к Chain-of-Thought prompting, нужно понять, что такое prompt.

Prompt — это текстовая инструкция, которую мы даём AI-модели. Проще говоря, prompt — это вопрос или задача, которую мы вводим.

Например, мы открываем чат с AI-инструментом и пишем: «Какая столица Франции?» Это предложение и есть prompt. Модель читает prompt и выдаёт ответ.

Иными словами, prompt — это способ сказать модели, что именно мы хотим получить.

Что такое LLM?

Теперь разберёмся, о каком типе моделей идёт речь.

LLM = Large Language Model, большая языковая модель.

Простыми словами, LLM — это модель, которая прочитала огромный объём текста и научилась предсказывать следующее слово. Это ключевая идея.

Допустим, мы вводим: «Небо…». Модель много раз видела подобные фразы, поэтому предсказывает следующее слово как «голубое». Затем она продолжает делать это слово за словом, пока не сформирует полный ответ.

LLM строит ответ по одному слову. Она не видит весь ответ целиком заранее. Она пишет ответ так же, как мы произносим предложение: одно слово за другим.

Такой способ генерации текста — по одному слову за раз — называется авторегрессией. У Outcome School есть отдельная подробная статья про авторегрессионные модели.

Эта единственная идея поможет понять, почему Chain-of-Thought prompting работает так хорошо.

Проблема: когда модель сразу прыгает к ответу

Возьмём простую математическую задачу словами.

В магазине есть 12 яблок. Утром магазин продаёт 5 яблок, а вечером покупает ещё 8. Сколько яблок теперь в магазине?

Правильный ответ — 15. Мы получаем его так: 12 − 5 = 7, затем 7 + 8 = 15.

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

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

Модель пишет слово за словом. Если она слишком рано «зафиксировалась» на финальном числе, у неё уже нет возможности исправить себя.

В этом и состоит основная проблема. И здесь на помощь приходит Chain-of-Thought prompting.

Что такое Chain-of-Thought (CoT) prompting?

Chain-of-Thought (CoT) prompting — это техника, при которой мы просим модель сначала расписать шаги рассуждения и только потом дать финальный ответ.

Проще говоря, вместо того чтобы просить ответ сразу, мы просим модель сначала «подумать вслух».

Разложим название, чтобы стало понятнее.

Chain-of-Thought = цепочка + мыслей.

Мысль — это один маленький шаг рассуждения. Цепочка — это несколько маленьких шагов, связанных друг с другом. Значит, Chain-of-Thought — это серия небольших рассуждений, которые ведут к финальному ответу.

Допустим, мы решаем задачу с яблоками. Мысли в цепочке выглядят так:

Мысль 1: начинаем с 12 яблок.
Мысль 2: продаём 5, значит 12 − 5 = 7 яблок.
Мысль 3: покупаем ещё 8, значит 7 + 8 = 15 яблок.
Финальный ответ: 15.

Здесь видно, что каждая мысль строится на предыдущей. Это и есть цепочка. Именно так Chain-of-Thought prompting направляет модель.

Разницу между двумя подходами можно представить так:

Без CoT — прыжок сразу к ответу:

Вопрос --> [угадать финальное число] --> Ответ (часто неверный)

С CoT — рассуждение по шагам:

Вопрос
  |
  v
Мысль 1: начинаем с 12 яблок
  |
  v
Мысль 2: 12 − 5 = 7 яблок
  |
  v
Мысль 3: 7 + 8 = 15 яблок
  |
  v
Финальный ответ: 15 (более надёжно)

Без CoT модель идёт от вопроса к ответу одним скачком. С CoT вопрос проходит через небольшие мысли одну за другой, и только последняя мысль приводит к финальному ответу.

Простой пример без CoT и с CoT

Лучший способ разобраться — посмотреть на пример.

Сначала prompt без Chain-of-Thought:

Q: В магазине есть 12 яблок. Утром он продаёт 5, вечером покупает ещё 8.
Сколько яблок теперь в магазине? Дай только финальное число.

Здесь мы попросили модель дать только итоговое число. Модель вынуждена прыгать сразу к ответу без пространства для рассуждения. На более сложных задачах это часто приводит к ошибкам.

Теперь добавим Chain-of-Thought к тому же prompt:

Q: В магазине есть 12 яблок. Утром он продаёт 5, вечером покупает ещё 8.
Сколько яблок теперь в магазине? Давай подумаем шаг за шагом.

Мы добавили в конец одну простую строку: «Давай подумаем шаг за шагом». Эта короткая фраза работает как триггер. Она говорит модели: сначала распиши рассуждение, потом дай ответ.

Теперь модель отвечает примерно так:

Начинаем с 12 яблок.
После продажи 5 остаётся 12 − 5 = 7 яблок.
После покупки ещё 8 становится 7 + 8 = 15 яблок.
Итак, финальный ответ — 15.

Модель сначала пишет шаги и только потом даёт финальный ответ. Рассуждение видно явно. Это Chain-of-Thought prompting в действии.

Задача решена.

Короткая заметка

В какой бы технической области вы ни работали, стоит познакомиться с этими темами:

LLM;
RAG;
MCP;
агенты;
fine-tuning;
quantization.

Outcome School собрали всё это в одном видео: AI Engineering Explained: LLM, RAG, MCP, Agent, Fine-Tuning, and Quantization.

Не обязательно отвлекаться прямо сейчас — можно добавить в закладки и посмотреть позже.

А теперь вернёмся к теме.

Zero-shot CoT и Few-shot CoT

У Chain-of-Thought prompting есть два распространённых подхода.

Первый — Zero-shot CoT.

«Zero-shot» означает, что мы не даём ни одного примера. Мы просто добавляем строку вроде «Давай подумаем шаг за шагом», и модель начинает рассуждать сама. Это самый простой способ, который мы уже видели выше.

Пример Zero-shot CoT prompt:

Q: Если поезд проезжает 60 км за 1 час, какое расстояние он проедет за 3 часа?
Давай подумаем шаг за шагом.

Мы не дали модели примеров. Только добавили фразу-триггер «Давай подумаем шаг за шагом». Модель сама выстраивает шаги.

Второй подход — Few-shot CoT.

«Few-shot» означает, что сначала мы даём несколько примеров. Мы показываем модели одну-две решённые задачи с полным рассуждением. Затем задаём реальный вопрос. Модель копирует тот же пошаговый стиль.

Пример Few-shot CoT prompt:

Q: В коробке 4 ручки. Мы добавляем ещё 3 ручки. Сколько ручек теперь?
A: Начинаем с 4 ручек. Добавляем 3, значит 4 + 3 = 7. Ответ: 7.

Q: В банке 10 конфет. Мы съедаем 6. Сколько конфет осталось?
A: Начинаем с 10 конфет. Съедаем 6, значит 10 − 6 = 4. Ответ: 4.

Q: На полке 8 книг. Мы добавляем ещё 5. Сколько книг теперь?
A:

Здесь мы сначала дали два решённых примера. Каждый пример показывает рассуждение, а не только ответ. Увидев этот паттерн, модель отвечает на третий вопрос в таком же пошаговом стиле: «Начинаем с 8 книг. Добавляем 5, значит 8 + 5 = 13. Ответ: 13».

Итак, Zero-shot CoT использует простую инструкцию, а Few-shot CoT использует решённые примеры, чтобы задать паттерн.

Различия между Zero-shot CoT и Few-shot CoT:

Пункт	Zero-shot CoT	Few-shot CoT
Примеры	Нет	Несколько решённых примеров
Как запускается рассуждение	Фразой вроде «Давай подумаем шаг за шагом»	Показом примеров с шагами
Длина prompt	Короткая	Длиннее
Сложность подготовки	Очень низкая	Выше, потому что нужно написать примеры
Лучше подходит для	Быстрых и типовых задач	Более сложных или необычных задач

Если вы хотите глубже освоить Prompt Engineering, Chain-of-Thought prompting и Prompt Chaining, Outcome School предлагает программу AI and Machine Learning.

Пошаговый разбор цепочки рассуждений

Теперь возьмём задачу чуть сложнее и пройдём цепочку шаг за шагом.

В классе 30 учеников. 12 из них играют в футбол. Половина оставшихся учеников играет в крикет. Сколько учеников играет в крикет?

Цепочка будет такой:

Шаг 1: всего 30 учеников.

Шаг 2: 12 учеников играют в футбол. Значит, осталось 30 − 12 = 18 учеников.

Шаг 3: половина оставшихся 18 учеников играет в крикет. Значит, 18 / 2 = 9.

Шаг 4: финальный ответ — 9 учеников играют в крикет.

Можно представить, как результат каждого шага переходит в следующий:

Шаг 1          Шаг 2               Шаг 3            Шаг 4
+--------+     +-------------+     +-------------+   +--------+
| всего  | --> | осталось    | --> | крикет      | ->| финал  |
| = 30   |     | = 30 − 12   |     | = 18 / 2    |   | = 9    |
|        |     | = 18        |     | = 9         |   |        |
+--------+     +-------------+     +-------------+   +--------+
                   ^                    ^
                   |                    |
             использует всего      использует остаток
             из шага 1             из шага 2

Каждый шаг использует результат предыдущего. Шагу 2 нужен общий размер класса из шага 1. Шагу 3 нужно количество оставшихся учеников из шага 2. Именно это связывание шагов и называется цепочкой.

Если бы модель попыталась угадать «9» одним прыжком, она легко могла бы ошибиться. Но, проходя каждый шаг, она остаётся на верном пути. Так Chain-of-Thought prompting снижает количество ошибок.

Почему Chain-of-Thought prompting работает?

Теперь главный вопрос: почему такой простой приём работает настолько хорошо?

Вспомним идею из начала статьи. LLM пишет ответ по одному слову, и каждое новое слово зависит от слов, которые уже были написаны.

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

Представьте, что мы считаем что-то сложное в уме. Ошибиться легко. Но если записывать каждый шаг на бумаге, шанс получить правильный ответ гораздо выше. Chain-of-Thought prompting даёт модели такую же «бумагу для записей».

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

То есть модель не становится умнее сама по себе. Мы просто даём ей пространство для мышления — причём структурированного. В этом красота Chain-of-Thought prompting.

Некоторые новые модели обучены выдавать такие шаги рассуждения самостоятельно, без специального prompt. У Outcome School есть подробная статья о large reasoning models, где объясняется, как это работает.

Где Chain-of-Thought prompting полезен

Теперь мы знаем, как это работает. Посмотрим, где это можно применять.

Математические задачи словами, где нужно несколько небольших вычислений.
Логические головоломки, где один неверный шаг ломает весь ответ.
Многошаговые вопросы, где ответ зависит от предыдущих фактов.
Задачи принятия решений, где нужно взвесить несколько вариантов.
Reading comprehension, где нужно связать разные части текста.

Во всех этих случаях ответ — не один факт. Он требует нескольких шагов. Chain-of-Thought prompting хорошо подходит именно для таких задач.

О чём важно помнить

Перед завершением — несколько важных моментов.

Chain-of-Thought prompting больше всего помогает на сложных многошаговых задачах. Для очень простых вопросов вроде «Какая столица Франции?» он не нужен: ответ — один факт, там нечего разбивать на шаги.
Рассуждение, которое пишет модель, полезно, но не всегда идеально. Модель может написать шаги, которые выглядят правильно, но всё равно прийти к неверному ответу. Поэтому в важных задачах нужно проверять шаги самостоятельно и не доверять им слепо.
Запись шагов означает, что модель генерирует больше текста. Больше текста требует немного больше времени и стоимости. Для большинства задач это разумный обмен на более надёжные ответы, но об этом стоит помнить.

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

Так работает Chain-of-Thought prompting — и именно поэтому такое маленькое изменение в prompt может дать такую большую разницу.

Для подготовки к AI Engineering interview: AI Engineering Interview Questions.

На этом всё.

Спасибо,
Amit Shekhar
Founder @ Outcome School

С автором можно связаться здесь:

Outcome School:

Все статьи Outcome School.

Также можно подписаться на newsletter, чтобы получать новые материалы по AI и Machine Learning.