Zero-shot, few-shot, and chain-of-thought handle most single-turn tasks. But some problems are too big, too uncertain, or too tool-dependent for one prompt to solve in one pass - and that's where three more advanced patterns come in: reasoning interleaved with action, voting across multiple attempts, and splitting one big ask into a pipeline of smaller ones.
ReAct: reasoning and acting, interleaved
ReAct (short for "Reason + Act") prompts the model to alternate between thinking through what it needs to do next and actually taking an action - calling a tool, running a search, checking a calculation - then reading the result before reasoning about the next step. It's the pattern underneath most tool-using agents: instead of trying to solve everything in its head, the model reasons just enough to decide "I should look this up," takes the action, and folds the real result back into its next reasoning step.
Self-consistency: asking multiple times and taking the majority answer
Self-consistency runs the same reasoning-heavy prompt several times - often with a bit of randomness in the model's sampling - and then takes the answer that shows up most often across the runs, rather than trusting any single attempt. It trades extra cost and latency for reliability on problems where a single chain-of-thought attempt has a meaningful chance of taking a wrong turn partway through, like multi-step arithmetic or logic puzzles with several valid-looking paths.
Three attempts, two agree on the same answer - self-consistency takes the majority result instead of trusting a single reasoning pass.
Prompt chaining: splitting one big ask into several small ones
Prompt chaining breaks a complex task into a sequence of smaller prompts, where each step's output feeds the next step's input - extract the key facts, then draft from those facts, then check the draft against the facts, for example, rather than asking for all three in a single instruction. Each individual prompt is easier to get right, easier to test in isolation, and easier to fix when something goes wrong, at the cost of more total calls and more plumbing to manage between steps.
Choosing between them
These three solve different problems: reach for ReAct when the task needs real-world information or actions the model can't produce from its own knowledge; reach for self-consistency when a task has real reasoning-error risk and you can afford multiple runs; reach for chaining when a task naturally breaks into stages, each of which benefits from focused attention. They also combine - a chained pipeline where one stage uses ReAct to gather facts and another uses self-consistency to double-check a calculation is a common shape for production systems.