Least-to-Most Prompting | Artizan Software

The Idea

When a problem is too hard to solve in one shot, don't just break it into pieces — break it into pieces ordered from easiest to hardest, then solve them in that order. Each solved piece gives AI the context it needs to tackle the next, harder piece.

This is how good teaching works: you don't start with calculus. You start with addition, build up to multiplication, then algebra, then calculus. Each skill builds on the one before it. Least-to-Most does the same thing with AI's reasoning.

Building Blocks

This composition extends:

Break Down the Question Think Step by Step

It takes question decomposition and adds a critical twist: solve the sub-problems in order from easiest to hardest, with each answer feeding into the next.

See It in Action

Problem: "I run 3 miles Monday, double that Tuesday, add 2 miles Wednesday, and triple Wednesday's distance Thursday. How far did I run total?"

Stage 1: Decompose

Break it into sub-problems, easiest first

AI plans the order

1. How far on Monday? (given directly)
2. How far on Tuesday? (depends on Monday)
3. How far on Wednesday? (depends on Tuesday)
4. How far on Thursday? (depends on Wednesday)
5. What's the total? (depends on all of the above)

↓ now solve in order, feeding answers forward

Stage 2: Solve

Solve each sub-problem with growing context

Sub-problem 1 (easiest)

How far on Monday? → 3 miles

Sub-problem 2 (with context: Monday = 3)

Double Monday's distance → 6 miles

Sub-problem 3 (with context: Mon = 3, Tue = 6)

Tuesday + 2 miles → 8 miles

Sub-problem 4 (with context: Mon = 3, Tue = 6, Wed = 8)

Triple Wednesday's distance → 24 miles

Sub-problem 5 (final)

Total: 3 + 6 + 8 + 24 = 41 miles

Each sub-problem is trivial on its own. The power is in the ordering — solving easy parts first gives AI the building blocks it needs for the harder parts.

Why This Works

Regular step-by-step reasoning fails when the problem is harder than any example AI has seen. It can solve simple cases but doesn't generalize to complex ones. Least-to-Most fixes this by ensuring AI never faces anything harder than a simple sub-problem.

The key insight: AI that can handle 2-step problems can't necessarily handle 10-step problems. But if you break a 10-step problem into ten 1-step problems and solve them in the right order, each step is trivially easy — and AI nails every one.

The Composition

Two stages: first decompose the problem into sub-problems ordered by difficulty. Then solve from easiest to hardest, giving each step the benefit of all previous answers.

How to Apply This

"Before solving this, break it into sub-problems ordered from simplest to most complex"
Solve the first (easiest) sub-problem
Include that answer when asking the next sub-problem
Keep going, building context each time, until you reach the original question

When to Use This

• Problems with a natural easy-to-hard progression, where earlier parts feed into later parts
• When AI handles simple versions of the problem but fails on complex ones
• Multi-step calculations where each step depends on the one before
• Tasks that require building up skills or facts incrementally

When to Skip This

• Simple questions — decomposition overhead isn't worth it for easy problems
• Problems without clear ordering — if there's no "easier" and "harder," this technique doesn't help
• Dynamic questions — if you need to adapt based on what you find, use Self-Ask instead

How It Relates

Least-to-Most is the structured cousin of Self-Ask. Both decompose problems, but Self-Ask generates sub-questions adaptively (each one based on what was learned), while Least-to-Most plans the whole decomposition upfront and executes in a fixed easy-to-hard order.

It extends Break Down the Question from a single-prompt suggestion into a two-stage process with ordering and context accumulation. And it complements Chain It — where Chain It is a general-purpose multi-step pattern, Least-to-Most specifically orders steps by increasing difficulty.