Chain-of-thought y razonamiento paso a paso

Chain-of-Thought (CoT) prompting is a technique where you ask the model to show its reasoning step by step before giving a final answer. Instead of jumping straight to the conclusion, the model produces intermediate reasoning steps that lead to the answer. This simple change dramatically improves accuracy on complex tasks involving math, logic, and multi-step reasoning.

The technique was introduced in a 2022 Google Brain paper that showed CoT prompting could enable large language models to solve math word problems that they completely failed at with direct prompting. The key insight is that generating intermediate steps forces the model to allocate more computation to hard problems.

The simplest form of chain-of-thought prompting is adding the phrase 'Let's think step by step' to your prompt. This zero-shot CoT trigger was discovered by researchers who found that this single phrase caused models to spontaneously produce reasoning chains even without few-shot examples.

LLMs generate text one token at a time, and each token is produced with a fixed amount of computation (one forward pass of the model). When you ask for a direct answer, the model must arrive at the correct answer in a single inference step, which is often too little computation for complex problems.

Chain-of-thought gives the model token budget to work with the problem. Each reasoning step is a token, and generating those tokens is equivalent to additional computation. This is why CoT works even on tasks where the model clearly knows all the individual facts — the bottleneck is not knowledge but the ability to combine facts over multiple reasoning steps in a single pass.

For maximum reliability, combine few-shot examples with chain-of-thought reasoning. Each example shows the full reasoning chain that leads to the correct answer. This teaches the model both the reasoning style you want and the correct format for the final answer.

Chain-of-thought is not limited to math. It dramatically improves performance on multi-hop reasoning tasks where you must connect several facts to answer a question. For example, answering 'Who was the president of the US when the iPhone was invented?' requires knowing when the iPhone was invented, then looking up who was president at that time — two separate knowledge lookups chained together.

Without CoT, the model must short-circuit this chain in a single step and often produces the wrong answer. With CoT, it explicitly retrieves each fact in a reasoning step, dramatically improving accuracy on these tasks.

In production applications, you often want the reasoning to be separate from the final answer so you can parse the answer programmatically. A common pattern is to instruct the model to wrap reasoning in tags and the final answer in its own section, making it easy to extract the answer without parsing the full reasoning text.

Self-consistency is an extension of CoT that generates multiple independent reasoning chains for the same problem using a high temperature, then takes a majority vote over the final answers. The intuition is that correct reasoning paths tend to converge on the same answer, while incorrect paths tend to diverge.

This significantly improves accuracy on math and commonsense reasoning benchmarks at the cost of additional API calls. It is most useful when accuracy matters more than latency or cost, such as in scientific or financial applications where a wrong answer has serious consequences.

Tree of Thought (ToT) extends chain-of-thought by exploring multiple reasoning branches simultaneously and evaluating which branch is most promising before continuing. Think of it like a search algorithm: rather than committing to one reasoning path, you generate several partial thoughts, score them, and expand the most promising ones.

This is particularly useful for planning and open-ended problems where the optimal reasoning path is not immediately clear. ToT requires significantly more API calls than basic CoT but can solve problems that linear CoT fails on, such as multi-step puzzles and creative problem-solving tasks.

CoT adds latency and token cost to every request. It is not always the right choice. Avoid CoT when:

• The task is simple and the model reliably gets it right without reasoning (e.g., single-step classification)
• You need very low latency and cannot afford extra tokens
• The reasoning itself would confuse downstream parsing (though structured output tags solve this)
• You are using a very small model that does not benefit from reasoning steps

CoT provides the most value on complex, multi-step tasks where the model demonstrably fails without it. Always measure before adding it to a production prompt.

Chain-of-thought is highly effective for code generation and debugging tasks. Asking the model to explain its plan before writing code — 'First explain your approach, then write the code' — produces more correct implementations because the planning step catches logical errors before they are encoded in the implementation.

For debugging, prompting the model to 'trace through the code step by step and identify where the output diverges from the expected value' is far more effective than just asking 'what is wrong with this code?' The step-by-step trace acts as a simulation of code execution within the model's reasoning.

You can encode chain-of-thought instructions permanently in your system prompt so that every user message benefits from step-by-step reasoning without users needing to request it explicitly. This is the standard pattern for production applications where you want reliable CoT behavior across all queries.

Test your understanding of AI Engineering concepts from this lesson.

In this lesson you learned: chain-of-thought prompting improves accuracy by making the model generate explicit reasoning steps before answering, self-consistency runs multiple chains and takes a majority vote for more reliable results, and CoT is most valuable for math, multi-hop reasoning, and debugging tasks, but adds latency and cost. Next up we explore how to write effective system prompts and define AI personas.