PromptCause
Donate

3 / 11

Decomposition

Least-to-Most

Intermediate

In short: Break into subproblems from easiest to hardest.

What is: Decompose the problem into subproblems ordered from easiest to hardest and solve them in sequence, where each answer feeds the next.

When to use: Reasoning with sequential dependency, step 3 needs step 2's result.

When to avoid: Problems that don't decompose naturally into dependent steps.

Right
Solve in stages, simplest to most complex: 1. How many items in month 1? 2. Using that, how many in month 2 (with +10%)? 3. And month 3? 4. Sum the three months.

Each subproblem is trivial alone; chained, they solve the whole.

Why: Zhou et al. (2022) showed that decomposing from simple to complex lets the model generalize to problems harder than the examples seen, something plain CoT doesn't do as well.

💡 Tip: Explicitly ask for each stage's output before moving on, so errors don't propagate silently.

Tree of Thoughts, ToT

Advanced

In short: Explore several reasoning paths and discard the bad ones.

What is: Instead of one line, the model explores several reasoning branches in parallel, evaluates each, and abandons those that don't lead to a solution. Like a chess player weighing moves.

When to use: Problems with several plausible approaches where you must compare and backtrack, planning, puzzles, optimization.

When to avoid: Simple tasks, the token cost is much higher than CoT.

Right
Solve this puzzle. Generate 3 different initial strategies. For each, judge in one sentence if it's promising or a dead end. Develop only the best; if it stalls, return to the second.

Explicit backtracking is what sets ToT apart from linear CoT.

Why: Yao et al. (2023) showed huge jumps on search tasks: on Game of 24, ToT solved 74% vs. 4% for CoT, because it can backtrack instead of marrying the first idea.

💡 Tip: Reserve it for problems where linear CoT fails. The cost only pays off when there really are multiple routes to explore.

Program-Aided LM (PAL) and Program of Thoughts (PoT)

Advanced

In short: The model writes code; an interpreter does the math.

What is: Instead of computing mentally, the model writes code (usually Python) representing the reasoning, and the calculation is run by an interpreter. Eliminates arithmetic errors.

When to use: Math, logic and data manipulation where numeric precision is critical and you can run the code.

When to avoid: When there's no runtime to execute, or the task isn't numeric/algorithmic.

Wrong
What's the compound interest on $10,000 at 1.3%/month for 18 months? Compute in your head.
Right
Write Python that computes compound interest on $10,000 at 1.3%/month for 18 months. Don't compute it yourself: generate the code, which will be executed. # 10000 * (1.013 ** 18)

Delegating the math to Python (which never errs at arithmetic) removes the model's error.

Why: Gao et al. (2022) showed that offloading the computation to an interpreter beats CoT on math benchmarks, the model only needs to translate the problem into code, which it does well.

💡 Tip: Ask for the code separate from the explanation, so you can run it directly without parsing.

Decomposed Prompting (DECOMP) and Skeleton-of-Thought

Advanced

In short: Break the task into sub-tasks; or outline before detailing.

What is: DECOMP breaks the task and delegates each sub-task to a specialized "handler" (another call or tool). Skeleton-of-Thought first generates the answer's skeleton (the headings) and then expands each point.

When to use: DECOMP in modular pipelines; Skeleton in long answers where keeping coverage and structure matters.

When to avoid: Short, direct answers, the extra structure adds nothing.

Right
Write a report on specialty coffee in two stages. Stage 1 (skeleton): list only the titles of the 6 sections. Stage 2 (expansion): develop each section into 1 paragraph.

Defining the skeleton first ensures a complete, well-organized report.

Why: Separating "what" (structure) from "how" (content) avoids the habit of over-expanding the first sections and rushing the last. Skeleton-of-Thought also lets you parallelize the expansion.

💡 Tip: In Skeleton, review and adjust the skeleton before expanding, fixing structure is cheap; rewriting all the content is expensive.