Caliber

Right size every Claude task.

Caliber is a set of Claude Code slash commands, plus an uploadable Claude skill for the website, that tells you which model and effort level to use for the task in front of you, instead of defaulting to the biggest model at the highest effort for everything.

It is advisory. It recommends, and you apply the choice yourself with /model and /effort. It prints the exact commands to paste, and it never switches anything on its own.

The idea

The question is not "what is the best model." The best model at the highest effort wins every task on quality and loses on cost and speed, and at the top it can overthink routine work. The real question is the cheapest model and effort whose expected cost of getting it wrong is acceptable for this task.

That is the deciding signal: cost of error. A cheap setup that fails or ships a subtle bug is not cheap, because you pay the tokens twice plus the cost of noticing, redoing, and cleaning up. A stronger setup you never needed is not free either. Caliber looks for the point where stepping up stops paying for itself.

Example

Running /caliber add rate limiting to the public API returns something like this. The first line reads whatever model and effort your session is actually on; this run assumes a session on Sonnet 5 at its default. The model names come from an editable catalog, so yours may differ:

Current session: Claude Sonnet 5 at high (assumed default from models.md)
Cost of error: High (public production endpoints, a wrong limit throttles real users or quietly lets abuse through)

▶ OPTIMAL (default for most tasks)
Claude Sonnet 5 at xhigh effort
Confidence it clears the task: High
Why: public limits reward deeper reasoning on burst behavior and abuse edge cases, and the mid tier stays far cheaper than the top
If it stalls: Claude Opus 4.8 at high
Apply (Claude Code): /model claude-sonnet-5 then /effort xhigh

BUDGET
Claude Sonnet 5 at high effort
Confidence it clears the task: High
Why: rate limiting is well trodden, and with tests and review the default effort clears it reliably
If it stalls: Claude Sonnet 5 at xhigh

SPLURGE
Claude Opus 4.8 at high effort
Confidence it clears the task: High
Why: worth it if the limits touch auth, billing, or shared distributed state where a quiet bug compounds
If it stalls: Claude Opus 4.8 at xhigh

Versus current session: a step up; same model, one effort notch up, buying deeper reasoning on the throttle logic for a modest extra token spend.

Three things to notice. The Budget is not the cheapest setup that might work; it is the cheapest whose confidence of clearing the task is High. The apply line is ready to paste, and it is never run for you. And the closing line frames the pick as a delta from the session you are already in, which is the decision you actually face: keep, step down, or step up.

Commands

Command	What it gives you
/caliber <task>	The catch all and the everyday default. All three options (Budget, Optimal, Splurge) at once with the current session line and the cost of error read, and Optimal marked as the default for most tasks.
/splurge <task>	The same three options, but marks the strongest setup that genuinely helps, for high stakes or hard work. Not the maximum that exists.
/budget <task>	The same three options, but marks the cheapest setup that still clears the task with high confidence.
/which-model <task>	Model recommendation only, as a narrow model ladder at one named effort.
/which-effort <task>	Effort recommendation only, as a narrow effort ladder, for the model you name in the task or the one your session is on.

On the Claude website only /caliber exists, because it is the uploaded skill. The other four are Claude Code slash commands. The command names are easy to change: rename a file in commands/ and the command name changes with it.

How it scores a task

It scores four signals from your task description:

• Complexity: how hard the thinking is and how far it reaches (reasoning depth, scope, context size, autonomy and length, domain difficulty). Drives the model tier and the effort floor.
• Cost of error: if the output is wrong, how expensive and how reversible that is, and how likely you are to catch it. This is the deciding signal for Splurge versus Budget. High and irreversible pushes up; low and instantly caught pushes down.
• Value: how much getting it right, or marginally better, matters to the outcome. Modulates how far up to go within the range cost of error allows.
• Viability: whether the cheaper tier can actually do this reliably, and whether you can verify and retry cheaply. Sets the confidence levels and can veto a tier, including any model whose context window the task does not fit.

It reasons in capability tiers (small, mid, top, frontier) and resolves a tier to a concrete current model only at the end, from models.md. It also reads the session it runs in: in the three-option views the output opens by naming the model and effort you are currently on and closes with whether the marked pick is a step up, a match, or a step down from there. Every recommendation carries a confidence level, a note on what to step up to if it stalls, and, for the marked pick, an apply line with the exact commands.

Requirements

• Claude Code for the full five command set, or
• claude.ai on a plan where Skills and code execution are enabled (Free, Pro, Max, Team, or Enterprise), for the /caliber skill.

Install in Claude Code (terminal)

Claude Code treats skills and slash commands as the same feature. The engine ships as a skill (which is itself the /caliber command), and the four focused commands ship as command files. All five work here.

git clone https://github.com/JordanGrothentic/caliber.git
cd caliber
mkdir -p ~/.claude/skills ~/.claude/commands
cp -r skills/caliber ~/.claude/skills/
cp commands/*.md ~/.claude/commands/

Then start or restart Claude Code and run /caliber add rate limiting to the public API as a smoke test. /splurge, /budget, /which-model, and /which-effort work too. If you would rather not clone, caliber.zip on the Releases page contains the same layout.

Scope notes. ~/.claude/skills/ and ~/.claude/commands/ apply to every project. To scope it to one repo and share it through version control, use that repo's .claude/skills/caliber/ and .claude/commands/ instead. Put the skill and the commands at the same scope.

How it triggers. /caliber fires when you type it, and Claude can also offer it when you ask in plain language, for example "which model should I use for this?". The four focused commands fire only when you type them; each carries disable-model-invocation: true in its frontmatter, because marking a tier is an explicit choice. To let one of them respond to plain language too, remove that line from the top of its file in commands/. This is unrelated to Claude Code's built-in /advisor feature, which has Claude consult a second model mid task. Caliber only advises you on which model and effort to pick.

Install in Claude on the web (claude.ai)

The website takes the skill, not the command files, so on the web you get the /caliber catch all advisor. Download caliber-skill.zip from the latest Release (both bundles are built and attached automatically when a version is tagged), or build it from the source:

cd skills && zip -r ../caliber-skill.zip caliber && cd ..

Then:

1. Turn the capability on. On Free, Pro, or Max, open Settings > Capabilities and enable both Code execution and file creation and Skills. On Team or Enterprise, an organization owner enables both under Organization settings > Skills first.
2. Upload it. Go to Customize > Skills, click the + (or Upload a skill), and select the zip. The skill appears in your list. Toggle it on.
3. Use it. Ask for it by name or in plain language, for example: "Use the caliber skill to size this task: migrate the users table to add a nullable column." Claude loads the engine and returns the Budget, Optimal, and Splurge options. Depending on your surface you may also see it when you type /.

Two honest limits on the web. First, only the catch all transfers; the four focused commands are Claude Code slash commands and do not exist on the website. Second, the website has no effort dial, and the engine handles that itself: its special case for surfaces without an effort dial leads with the model pick, marks the effort half of each option as applying in Claude Code or the API, and never tells you to run /model or /effort there. The model pick is directly usable in the web model picker, and it is the larger lever anyway.

Keeping it current

There is no self healing and nothing is fetched at runtime. You keep it current by editing one file.

• Edit only skills/caliber/models.md when a model ships, an effort level changes, or a price moves. The engine in SKILL.md and the command files read tiers, names, effort support, defaults, prices, and context sizes from there.
• Fields to update in models.md: the current models table, the previous generation and provider alias table, and the effort levels table.
• Source capability notes and pricing from the official docs linked at the top of models.md.
• Bump the "Last updated" date at the top of models.md.
• If you edit the skill and re-upload it to the website, the description must stay at or under 200 characters or the upload is rejected.

The catalog is re-verified when a model ships rather than on a fixed schedule, so the Last updated date at the top of models.md is the freshness signal. A working heuristic: if that date is more than about eight weeks old, verify prices against the docs linked in the catalog before trusting the dollar comparisons. Tiers change much slower than prices, so the shape of the advice ages better than the numbers. The engine carries its own guard too: once the catalog is more than about three months old, every output includes a warning line saying to verify names and prices before trusting them.

How we know it works

Recommendations are judgment, not computation, so there is no benchmark score to point at. Validation is structure and spread instead:

• evals/golden-tasks.md: a spread of representative tasks with the tier band each should land in, and why.
• evals/invariants.md: the mechanically checkable rules every output must satisfy (tier ordering, honest confidence, names and prices that match the catalog).
• examples/: golden runs of the current engine on that spread, recorded honestly, misses included.

Output text is nondeterministic, so the regression check is the invariants list, not a verbatim diff.

If this were native

Caliber is shaped like the feature it wants to become. It already knows which model your session is running, so the recommendation arrives as a delta (keep, step down, step up) rather than a chart to cross-reference, and applying it is one pasted line. Native, the same hint would appear before a heavyweight task starts and applying it would be one keystroke; until then, the skill gets as close as text can.

Proactive mode (opt in). The skill already answers plain language, so asking "which model should I use for this?" surfaces it without the slash command. The four focused commands fire only when typed, on purpose; to make any of them respond to plain language too, delete the disable-model-invocation: true line from its file in commands/.

Good to know

• Recommendations are confidence rated guidance, not guarantees. Model selection is probabilistic. Confidence is a judged probability that the tier clears the task, not a measured number.
• You apply the choice yourself with /model and /effort. The apply line gives you the exact commands, and the tool never runs them for you.
• Recommendations name the current model for a tier. Match them to what your plan and provider actually expose. The aliases opus, sonnet, and haiku resolve to different versions across the Claude API, Claude Platform on AWS, Bedrock, Vertex, and Foundry, and effort ceilings differ by model. If your mid or top model lacks xhigh, an effort recommendation of xhigh runs as high there.
• Effort is calibrated per model. The same level name is not the same amount of reasoning across models, which is why the engine reads each model's supported levels rather than assuming a shared scale.

Contributing

Issues and pull requests are welcome. Most changes are a data edit in skills/caliber/models.md (a new model, a price change, an effort tweak) rather than a logic change, because the engine is model agnostic on purpose. The house rules and the validation flow (no em dashes, the 200 character description cap, the tier ordering invariant, the golden tasks) live in CONTRIBUTING.md.

License

MIT. See LICENSE.