How this maps onto Claude Code

Same rubric. Claude Code's own tiers underneath it.

Undercut's tier names — cheap, standard, frontier, apex — are generic on purpose. For Claude Code, models.md resolves each one to the closest Claude model at that capability level: cheap maps to the smallest/fastest model in the family, standard to the default work model, frontier to the highest-reasoning production model, and apex is reserved for the single batched tie-break call when the ladder is exhausted. The mapping is versioned separately from the rubric, so a new Claude release updates the model slug without touching the escalation logic itself.

Nothing about this sits between Claude Code and the Anthropic API. It's a policy file Claude Code reads at dispatch time, same as any other skill — no proxy, no network hop, nothing to route around if you remove it.

Install for Claude Code

Free. MIT. Nothing installs, nothing proxies your traffic.

Option 1 — plugin (fewest keystrokes)

This repo doubles as its own plugin marketplace — no separate registry, just .claude-plugin/ in the repo you're already installing from.

      $ /plugin marketplace add undercutsh/firstpass
      
    

      $ /plugin install firstpass@firstpass
      
    

Two separate prompts — send the marketplace command, wait for it to finish, then send the install command. Uninstall any time with /plugin remove firstpass.

Option 2 — skills CLI

      $ npx skills add undercutsh/firstpass
      
    

Option 3 — copy the skill directory directly

Clone or download undercutsh/firstpass, then copy skills/firstpass/ into wherever your Claude Code setup reads skills from — project-level or user-level, same convention as any other skill.

      $ mkdir -p .claude/skills && cp -r firstpass/skills/firstpass ./.claude/skills/firstpass
      
    

Validate it yourself

1Read the published results — testing/README.md and the raw JSON in testing/results/
2Reproduce for free, no API key, no spend: node src/main.js --mock
3Run live on the Anthropic family with an OpenRouter key — a single-vendor smoke test is pennies

Zero lock-in. It's a policy Claude Code follows — remove the skill and you're back to status quo.

How it works

The Undercut Rubric · v1

Six flags assign a tier. Three triggers are the only way up.

This is a named, versioned spec — not internal logic we could quietly change. When the rubric changes (a new flag, a different cap), the version number moves and the changelog says why.

Every unit of work gets scored against six flags, then assigned the cheapest tier that can plausibly handle it. It only moves up a tier when something objective proves it needs to — a failed check, a measured disagreement, an explicit uncertainty flag. It never moves up on a guess, and it never moves back down mid-task.

unit of work
›
6-flag rubric
›
0 flagscheap~90% of units land here ✓
1–2standard
3+/ownfrontier

        ↑ escalate +1 tier
        only on: fail ×2 · two runs disagree · tagged "uncertain"
        residue only — never redoes the batch
      

See the rubric

Step 1 — Base tier, six-flag rubric

Unverifiable — can output be checked mechanically? (tests, schema, diff, grep)

Ambiguous — one right answer, or several defensible ones?

Blast — reversible? touches money, auth, user data, production, deletes?

Cross-cutting — one file/source, or reasoning across many?

Novel — pattern-following, or genuinely new design?

Format-strict — must output match an exact schema?

0 flags → cheap · 1–2 → standard · 3+ or any ownership/judgment call → frontier. Apex only when you can write one sentence stating why the marginal intelligence pays for the cost.

The override — single biggest lever

Cheap-to-verify ⇒ cheap-to-generate. If output can be checked mechanically, it starts at the lowest tier regardless of how hard it looks — verification catches failure. Only unverifiable work needs to start high.

Step 2 — Escalate exactly one tier, on evidence only

Verification fails twice at the current tier
Two cheap-tier runs disagree on ambiguous-flagged work
The worker tags an item "uncertain"

Residue-only handoff

The next tier up gets only the failed or uncertain items, plus verification notes. It resolves the residue — it never redoes the batch.

Hysteresis — guardrails

Never de-escalate mid-task. Max one retry per tier. Anything still unresolved goes to a single batched apex tie-break call. One hard file in a 700-file job doesn't drag the other 699 up a tier.

 unit of work
      |
  6-flag rubric
      |
  +---+----+
  | 0 flags|--> cheap
  | 1-2    |--> standard
  | 3+/own |--> frontier
  +---+----+
      | fail x2 / disagree / uncertain
      v
  escalate +1 tier
  (residue only)
      |
  still unresolved?
      v
  single batched
  apex tie-break

Why it holds up

Flags steer. Verification and escalation decide.

Even when the rubric flags are scored imperfectly, the escalator still routes work to the right tier almost every time — because a wrong flag only ever costs one extra cheap attempt, never a wrong answer or a big bill.

See the data

A stock dispatcher model reproduces the rubric flags imperfectly — Haiku hits 90% agreement, Sonnet 93%. The weakest flag (format-strict) is only 60%. None of that matters: under the shipped policy, both dispatchers still route 100% of units to the correct tier. A wrong flag changes the ladder cap, never the base tier — worst case, one extra cheap attempt.

Haiku dispatcher
90% flag agreement
100% tier-match
Sonnet dispatcher
93% flag agreement
100% tier-match

The rules are about the work, not the model.

Every rule is a property of the unit of work — verifiable, ambiguous, blast-radius — never a specific model's known weakness. Vendor cards go stale as models change; work properties don't. It's also hard-won — a format-strict rule that worked on Anthropic backfired on Gemini, which is exactly why the rubric no longer encodes per-vendor behavior.

Claude Code already reads a SKILL.md. Give it one that stops overpaying.