Reasoning least to most
Skill firststone-vc/reasoning-pack/skills/reasoning-least-to-most
Make a cheap model reason like Claude Fable 5 - 11 installable Claude skills: plan-then-execute, self-consistency, reflexion, tree-of-thoughts, verification and more. MIT.
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.
What its author says it does
Copied from the file, not written here
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.
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.