least-to-most

name	least-to-most
description	For a complex problem, first decompose it into an ordered list of simpler subproblems, then solve them in sequence, feeding each answer into the next, instead of one-shotting the whole thing. Use on multi-step tasks, hard algorithmic problems, or anything that fails when attempted whole. Trigger with /least-to-most or "break this down", "decompose first", "solve step by step in order".
version	0.1.0
user-invocable	true
metadata	{"emoji":"🪜"}

least-to-most

Hard problems fail when attempted in one leap. Decompose into ordered subproblems (easiest/foundational first), solve each using the answers from the earlier ones, then assemble. Explicit decomposition, sequential solving.

Why this exists (evidence)

• Least-to-most prompting (Zhou et al., arXiv:2205.10625): decompose-then-solve-in-sequence generalizes to harder problems than chain-of-thought, with large gains on compositional generalization (e.g. SCAN) and multi-step reasoning, precisely because later steps build on solved earlier ones.
• It targets the failure where a model can do each step but botches the leap when forced to do them all at once.

When to use

• Multi-step tasks where step N depends on step N-1 (migrations, multi-file refactors, algorithmic problems, data pipelines).
• A task that keeps failing when attempted whole.
• NOT for simple or already-atomic tasks (decomposition is overhead there).

The method

1. Decompose: list the subproblems in dependency order, simplest/foundational first. Make the ordering explicit (each item names what it needs from prior items).
2. Solve in sequence: solve subproblem 1; carry its concrete answer into subproblem 2; and so on. Do not skip ahead.
3. Assemble: combine the sub-answers into the full solution.
4. Check the seams: verify the points where one sub-answer feeds the next (that is where composition errors hide).

How to run it

• Inline: write the ordered subproblem list, then solve down the list.
• For code: decompose into the ordered edits/functions; implement+verify each before the next (composes with TDD/testsmith per step).
• Distinct from orchestrate (which is the plan->spec->build->verify dev cycle with a gate); least-to-most is the reasoning-decomposition technique you can use INSIDE any step.

Composes with

• orchestrate: least-to-most is how you fill the PLAN step.
• reflexion: if a subproblem fails, reflect before retrying that one (not the whole chain).
• self-consistency: sample the decomposition itself when the right breakdown is unclear.

Honest limits

• A wrong decomposition propagates: if the ordering/breakdown is off, every step inherits it. Sanity-check the decomposition before solving.
• Overhead on simple tasks; scope to genuinely compositional problems.
• Gains are on the paper's benchmarks; measure your own.