Reasoning least to most
Skill firststone-vc/reasoning-pack/skills/reasoning-least-to-most
Decompose a hard, multi-step problem into an ordered chain of easier sub-problems and solve them in sequence, feeding each answer into the next, so the final (hardest) step is solved last with all the groundwork already done. Trigger for multi-hop questions, compositional math/logic problems, nested planning tasks, or any problem that is too big to answer correctly in one hop — especially with a weaker/cheaper model that tends to skip steps or drop terms when asked to jump straight to the answer.From its SKILL.md
npx -y skills add firststone-vc/reasoning-pack --skill reasoning-least-to-mostAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
4.9 KB, ~1.1k tokens by cl100k_base, as published. Nobody here has run it
reasoning-least-to-most — climb to the hard answer via easy steps
Source technique: least-to-most prompting (Zhou et al., 2022). Two separate moves, always in this order: (1) decompose the target problem into an ordered list of sub-problems, easiest/most foundational first, ending in the original question; (2) solve sequentially, using every prior answer as given, verified context for the next step. Never attempt the final answer directly — earn it through the chain.
Why this helps a cheap model
A weak model asked to solve a compound problem in one shot often skips an intermediate quantity, reuses the wrong number, or hallucinates a shortcut. Forcing an explicit, ordered decomposition — solved one link at a time, with each prior answer written down and carried forward — removes the need to hold the whole derivation in one leap of attention. This is a reasoning procedure, not a capability injection: it does not make the model know something it doesn't; it stops it from losing track of what it already knows.
When to use
- The problem has a strict dependency chain: sub-question 2 cannot be answered without the answer to sub-question 1 (multi-hop QA, nested word problems, staged planning, compositional generalization, multi-stage code logic).
- The task is bigger/longer than worked examples the model has seen, so it must build the answer up rather than pattern-match it.
When NOT to use
- Sub-tasks are independent and could run in any order or in parallel (e.g. "summarize these 5 unrelated documents") — that's divide-and-conquer/map-reduce, a different technique.
- The question is a single-fact lookup or one-hop — decomposition only adds latency for no gain.
- The task is open-ended creative generation with no verifiable intermediate facts.
Inputs required
- Target problem/question (required) — the thing that must ultimately be answered.
- Domain context / constraints (optional) — facts, numbers, or rules the solver must respect.
- Max decomposition depth (optional, default 5) — cap on how many sub-questions to allow before flagging the problem as needing a different technique.
Step-by-step procedure
- Test decomposability. Ask: "Can this be broken into an ORDERED chain where each sub-answer is a required input to the next, ending in the original question?" If sub-tasks are independent, stop and use a different technique.
- Decompose top-down, before solving anything. Write the full ordered list Q1 … Qn, where Qn is the original question restated using the vocabulary established by Q1…Q(n-1). Do this without computing any answers yet.
- Solve bottom-up, one link at a time. Answer Q1 using only the original context. Answer Q2 using the original context plus A1. Continue, always carrying forward all prior answers as established facts — never re-derive from scratch and never skip citing which prior answer a step depends on.
- Solve the target last. Qn (the original question) is answered using the full accumulated scaffold of A1…A(n-1) as given facts, not as a fresh problem.
- Sanity check. If any Ai was never referenced by a later step, the decomposition had a dead branch — redo it. If the final answer had to skip or re-guess a quantity instead of using an Ai, the chain is broken — restart step 2.
Output format
Always render both blocks, in this order, before the final line:
Decomposition
Numbered list Q1 … Qn (Qn = the original question, restated).
Stepwise solution
For each i, one line pair:
Qi: <sub-question> → Ai: <short reasoning citing which prior Aj it uses> = <answer>
Final answer
One line, stated plainly, equal to An.
Worked example
Target: "A bookstore had 3 shelves of 24 books each. It sold two-thirds of them during a sale, then received a new delivery of 40 books. How many books does it have now?"
Decomposition
- Q1: How many books did the store start with?
- Q2: How many books did it sell in the sale?
- Q3: How many books were left after the sale?
- Q4 (target): How many books does it have after the new delivery?
Stepwise solution
- Q1: 3 shelves × 24 books = 72. → A1: 72 books.
- Q2: sold two-thirds of A1 (72) → 72 × 2/3 = 48. → A2: 48 books sold.
- Q3: remaining = A1 − A2 = 72 − 48 = 24. → A3: 24 books left.
- Q4: A3 + new delivery of 40 = 24 + 40 = 64. → A4: 64 books.
Final answer 64 books.
What ships with it
Read from the repository
Just SKILL.md. No reference files, no scripts.