Reasoning step back
Skill firststone-vc/reasoning-pack/skills/reasoning-step-back
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-step-backAssembled 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
Use when a question is gated by an underlying general principle, law, rule, doctrine, or framework (physics, law, strategy, medicine, economics) that must be correctly identified before the specific case can be solved — especially when jumping straight to the specific numbers/facts risks skipping or silently misapplying that principle. Not for pure lookup, formatting, or extraction tasks with no governing concept.
SKILL.md
8.2 KB, ~1.8k tokens by cl100k_base, as published. Nobody here has run it
Step-Back Prompting — abstract first, instantiate second
What this is (honestly): a two-hop retrieval-and-application order, not a capability upgrade. The model does not learn any new principle by doing this. What changes is the SEQUENCE: instead of reasoning directly on the concrete instance (where the specific numbers/names/dates crowd out the governing rule and the model pattern-matches to "a similar-looking answer"), the model first steps back and states the general, context-free question or principle that governs the case, answers THAT in the abstract, then plugs the specific facts into the validated abstraction. This is the published "Take a Step Back" pattern (Zheng et al., 2023): abstraction-before-instantiation measurably helps on STEM, knowledge-QA, and multi-hop reasoning specifically because it stops surface details from hijacking which rule gets applied.
What it isn't:
- Not chain-of-thought — CoT reasons step by step at the same level of abstraction, on the concrete problem, from the start. Step-back inserts one deliberate level-SHIFT (concrete → abstract → concrete) before any CoT-style chaining begins.
- Not least-to-most — least-to-most decomposes a hard instance into a sequence of easier instances of the same kind. Step-back doesn't decompose the case; it asks what higher-level concept the whole case is an instance OF.
- Not retrieval/RAG — nothing external is fetched. The "general principle" is generated by the model itself, which is exactly why it needs the guardrail below.
When to use
- The question hinges on a named principle, law, formula, legal test/element, doctrine, or strategic framework that the model plausibly knows in the abstract but risks skipping or misapplying when it dives straight into the specific numbers or facts.
- Domains where this reliably pays off: physics/chemistry problems with conditions or edge cases (which law applies here?), legal questions that turn on which test/element/exception governs a fact pattern, strategy or business questions governed by a general framework (e.g., which negotiation principle, which economic effect), differential-diagnosis-style reasoning (what syndrome/class before this specific presentation).
- Signal to watch for: if you'd expect a competent human expert to say "wait, what rule are we even applying here?" before touching the specific numbers, this technique fits.
When NOT to use
- Pure factual lookup, extraction, formatting, summarization, or translation — there is no governing principle to step back to, so the extra hop is pure overhead.
- The correct principle is already stated in the prompt or is trivially unambiguous — skip straight to application.
- Niche or obscure domains where the model is likely to confidently invent a plausible-sounding but nonexistent "general principle" (a fake legal doctrine, a misremembered formula) and no way exists to check it — see guardrail below; in that case a verifier-loop or external reference is a prerequisite, not optional.
- Arbitrary/idiosyncratic questions with no meaningful "general case" (e.g., "what's my coworker's favorite color") — nothing to abstract.
Inputs required
- Specific question/case — the concrete instance to be solved.
- Domain hint (optional but recommended) — physics, contract law, negotiation, etc. — primes which family of principles to search.
- Reference material (optional, strongly recommended when stakes are high) — a textbook rule, statute text, or known-correct formula to check the stepped-back principle against, so the abstraction isn't taken purely on the model's say-so.
Procedure
- Read, don't answer yet. State the specific question but do not compute or conclude anything about it in this step.
- Step back. Ask explicitly: "What is the general principle / law / rule / question that governs a case like this?" Write it as a standalone, context-free statement — it should make sense with the specific names, numbers, and parties removed entirely.
- Answer the abstraction. Resolve the general question on its own terms (state the law, formula, test, or framework, including its conditions and known exceptions), independent of the case's specific facts.
- Guardrail — check before applying. Ask: does this principle actually fit the case, or does a condition/exception in the specific facts point to a different principle? If reference material is available, verify the stated principle against it now, before using it. This is the step most failures skip, and skipping it is how step-back goes wrong: a confidently wrong "general law" applied cleanly to correct facts still produces a confidently wrong answer.
- Instantiate. Substitute the case's specific facts, numbers, or parties into the checked general answer.
- Derive the specific answer, keeping the link from principle → instance explicit, so if the final answer is wrong, it's diagnosable whether the principle was wrong or the substitution was wrong.
- Report both layers (format below) — never collapse the abstraction and the application into one paragraph; keeping them separate is what makes this technique auditable.
Output format
## Step back
**Abstract question:** <the case with names/numbers stripped out>
**General principle:** <the law/rule/formula/test, with its conditions>
**Check:** <verified against <source> | not verified — flag as risk>
## Apply to the case
**Specific facts:** <the actual names/numbers/parties>
**Instantiation:** <the principle with the specific facts substituted in>
## Answer
<final result, derived from the instantiation>
Worked example
Task: "An ideal gas is held at temperature T1 and volume V1 with pressure P1. The temperature is increased to 2×T1 and the volume is increased to 8×V1, with the amount of gas unchanged. What happens to the pressure?"
- Read, don't answer yet: noted — do not touch the "2×" and "8×" factors yet.
- Step back: "What is the general relationship between pressure, volume, temperature, and amount of gas for an ideal gas?"
- Answer the abstraction: the ideal gas law, PV = nRT, holding for a fixed amount n of an ideal gas — so P = nRT / V, and for two states with the same n: P1·V1/T1 = P2·V2/T2.
- Guardrail: does the ideal gas assumption hold here? The problem states "ideal gas" and "amount of gas unchanged" (n constant) explicitly — no exception applies, so the law is safe to use. (If the problem had instead said "real gas near its critical point," this step is where you'd catch that PV = nRT is the wrong model.)
- Instantiate: P1·V1/T1 = P2·V2/T2 → P2 = P1 · (V1/V2) · (T2/T1) = P1 · (V1 / 8V1) · (2T1 / T1) = P1 · (1/8) · 2.
- Derive: P2 = P1 / 4 — the pressure drops to one quarter of its original value.
- Report:
## Step back
Abstract question: For a fixed amount of ideal gas, how are pressure, volume, and temperature related?
General principle: Ideal gas law, PV = nRT ⇒ P1V1/T1 = P2V2/T2 for constant n.
Check: verified — problem explicitly states "ideal gas" and constant amount, no phase-change or high-pressure exception flagged.
## Apply to the case
Specific facts: V2 = 8·V1, T2 = 2·T1, n constant.
Instantiation: P2 = P1 · (V1/8V1) · (2T1/T1) = P1 · (1/8) · 2
## Answer
P2 = P1 / 4 — the pressure falls to a quarter of its starting value.
See also
chain-of-thought (reasons within the concrete instance; step-back happens before it starts), least-to-most (decomposes into easier same-level sub-problems; step-back moves up a level instead), verifier-loop (pair with it to check the stated general principle itself when no external reference is available), reasoning-budget-router (if the abstraction step is a known weak spot for the cheap tier, escalate just that step).
What ships with it
Read from the repository
Just SKILL.md. No reference files, no scripts.