Reasoning Pack

11 installable Claude skills that give a cheap model the reasoning habits of an expensive one.

No model swap. No leaked prompts. No magic. A prompt can't add capability that isn't already in a model's weights — so this pack doesn't raise a model's ceiling, it squeezes it: it wraps a cheaper model in a reasoning harness (plan → sample & vote → self-critique → verify) so it uses the capability it does have far more deliberately.

On easy and medium tasks that lands close to a premium model. On genuinely hard reasoning it won't match one — and each skill tells you honestly where its limit is.

Why this actually saves money

The premium models are metered API — you pay per token, and the bill grows with use. The cheaper models this pack is built for come included in your subscription (flat rate). So the marginal cost of making a subscription model reason 10× harder is close to zero: you spend a little of your plan's quota and some patience (it's slower), not API dollars. It moves work from the "API that bleeds" column to the "already paid for" column.

What's inside — 10 techniques + 1 bonus

The 10 core reasoning techniques

# Skill What it does
1 reasoning-plan-then-execute Break the task into explicit steps and solve them one at a time, checking each before moving on.
2 reasoning-self-consistency Generate several independent answers and keep the one that recurs most.
3 reasoning-reflexion Re-read the draft, hunt for its own mistakes, and fix them before answering.
4 reasoning-verifier-loop A skeptical verifier tries to break the answer; if it succeeds, retry with the reason.
5 reasoning-least-to-most Solve the easy sub-problems first and use them as stepping stones to the hard one.
6 reasoning-rubric-grader Score the answer against an explicit quality rubric before calling it done.
7 reasoning-scratchpad-cot Think step by step on a separate scratchpad, then emit only the clean final answer.
8 reasoning-chain-of-verification Self-interrogate with verification questions to catch factual errors and hallucinations.
9 reasoning-tree-of-thoughts Explore several reasoning branches, evaluate them, and keep the most promising.
10 reasoning-step-back Step back to the governing principle first, then apply it to the specific case.

The bonus (+1) — the one that pays for itself

# Skill What it does
⭐ reasoning-budget-router Start cheap and escalate only the specific chunk that needs it — so you pay premium prices for the ~10% that truly requires it, and subscription-priced reasoning for the rest.

Install

Each skill is a self-contained SKILL.md in its own folder. Claude Code loads skills from ~/.claude/skills/. Pick one:

A) All of them, globally

git clone https://github.com/firststone-vc/reasoning-pack.git
cp -r reasoning-pack/skills/* ~/.claude/skills/

B) A single skill

# copy just the folder you want, e.g. the bonus router
cp -r reasoning-pack/skills/reasoning-budget-router ~/.claude/skills/

C) Per project (only for one repo)

mkdir -p .claude/skills
cp -r reasoning-pack/skills/* .claude/skills/

Then invoke a skill by name in Claude Code, or let the model pick the right one for the task.

Honest limits

  • It does not turn a small model into a big one. Capability lives in the weights; this organizes reasoning, it doesn't add IQ.
  • On hard, multi-step reasoning the cheap model plateaus — reasoning-budget-router is there precisely to escalate that part instead of faking it.
  • More reasoning = more tokens and more latency. Great trade on subscription models; think twice if you're paying metered API for every step.

All techniques are based on public, reproducible research (chain-of-thought, self-consistency, reflexion, tree-of-thoughts, step-back prompting, chain-of-verification, and more) — not on secret or leaked prompts.

Getting the most out of these skills

A few principles that make any of these skills work better:

  • Define the output contract first. Tell the model the exact shape you want (JSON, a table, "one sentence") before giving it freedom — creativity inside safe margins beats an open-ended guess.
  • Ask for honesty about limits, not false certainty. Add "if you're unsure, say so" — an honest "not stated in the source" is worth more than a confident wrong answer.
  • Match effort to consequence. Reserve the heavy harness (sampling, verification) for steps where being wrong is expensive; keep the easy stuff light.
  • Order by what happens most. Handle the common case first; edge cases after.
  • Show one worked example. A single "good vs bad" example steers the model more than another paragraph of rules.

About FirstStone

The Reasoning Pack is open source (MIT) and maintained by FirstStone — the AI-founder ecosystem that helps founders build, raise, and grow with honest systems instead of magic shortcuts.

If this saved you money or made your cheap model punch above its weight, leave a ⭐ — it helps it reach more people.

License

MIT © 2026 FirstStone. Use it, fork it, ship it.