Chain of Thought (CoT)

When the AI shows its work - reasoning step-by-step before writing code.

The simple explanation

Remember math class, where showing your work was just as important as the final answer? Chain of thought is the same idea for AI. Instead of jumping straight from a question to an answer, the model reasons through intermediate steps.

Without chain of thought, ask an AI to refactor a complex function and it might jump straight to rewriting it - potentially missing edge cases or breaking assumptions. With chain of thought, the model first identifies what the function does, what its callers expect, what could go wrong, and then produces the refactored version.

Modern models like Claude use "extended thinking" - a dedicated reasoning phase before generating the final response. You can literally see the model working through the problem, which also makes it much easier to spot where it went wrong if the output isn't right.

Why it matters for agentic engineering

Chain of thought is what makes AI capable of handling complex coding tasks rather than just simple one-liners. When an agent plans an implementation, chain of thought is how it reasons about architecture, identifies dependencies, considers edge cases, and sequences its work.

For agentic engineers, visible chain of thought is a debugging tool. If the agent produces wrong code, you can read its reasoning to understand why - maybe it misunderstood a requirement, or correctly identified the problem but chose a flawed approach. This makes iteration much faster than treating the agent as a black box.

In practice

• Extended thinking: Models with dedicated reasoning modes (like Claude's extended thinking) produce significantly better code for complex tasks - the tradeoff is more tokens and more latency
• Prompting for reasoning: Phrases like "think step by step" or "analyze the codebase before making changes" can encourage chain of thought even in models without dedicated reasoning modes
• Debugging aid: When code is wrong, read the model's reasoning first. Often the error is in the logic, not the implementation
• Planning phase: In the plan-act-observe loop, chain of thought is what drives the planning phase - the agent reasons about what to do before doing it
• Tradeoff: More thinking = better results but higher cost and latency. For simple tasks (rename a variable, add a log statement), chain of thought is overkill