9arm's skills repo is small, but it has one cost idea worth stealing

I have reviewed four Claude Code skill repos so far, some with hundreds of thousands of stars. This one is different. 9arm, a Thai creator, has a repo of around 2,900 stars, far smaller, just 6 skills, and its bucket layout is borrowed straight from Matt Pocock's repo.

To be straight: on scale or fame, this repo isn't in the same league as the other four. But it has one skill sharp enough to be worth writing up, and it covers something the other four don't: controlling cost by choosing which model does which job. So this isn't a review of the whole set. It's taking the single most useful idea.

What skills are in 9arm's repo (all 6)

If you came here to find what skills are inside the 9arm-skills repo, here they are, read straight from the SKILL.md files, in two buckets.

Engineering

• debug-mantra a four-step debugging protocol: reproduce the bug first, trace the code path, try to falsify your own hypothesis, then verify the breadcrumbs.
• post-mortem writes up a resolved bug with its root cause, mechanism, fix, and the validation that it is actually gone.
• scrutinize has the AI review a plan or code change from an outsider's view, questioning intent and checking whether the claims hold.
• qwen-agent hands grunt work to a Qwen-backed subagent, such as bulk renames, formatting, and scaffolding.

Productivity

• management-talk reframes technical content into language you can use with engineering leadership across channels.
• qwenchance keeps long tasks alive so the agent doesn't loop or overflow its context, breaking or handing off at that point.

The two we would actually reach for are the Qwen pair, qwen-agent and qwenchance, because they are the cost idea we unpack below. The rest are solid but common enough to find elsewhere.

Part 1The sharp idea: send grunt work to a cheap model

The skill called qwen-agent does one thing, and does it well. It splits work into two piles. The repetitive, low-thought work, renaming variables across a file, writing boilerplate, summarizing long logs, gets sent to a cheap model like Qwen instead. The more expensive main model is kept for the work that genuinely needs judgment.

What makes it hold up in practice is that it forces large jobs to be split into pieces that fit the cheap model's smaller context, rather than dumping the whole thing and hoping. There's a companion skill, qwenchance, that watches for the agent re-reading the same file in a loop, or thinking for a thousand words without acting, and makes it break or hand off, so tokens don't quietly burn.

Part 2Why it works: match the task's value to the tool's price

This lines up with a principle I hold anyway: don't push everything through the single most expensive model. Jobs aren't worth the same. Work that's easy to check and needs no interpretation should sit with the cheapest thing that can do it, a cheap model or plain code. Work that needs context or a judgment call is where you pay for the expensive model.

Think this way and cost follows the value of the work instead of being flat and high across everything. And it doesn't cost you quality, because the work that needs a strong model still gets one. You just stop melting the expensive one on jobs a cheap tool handles fine.

Part 3How to put the idea on your own machine (step by step)

Once you want to try it for real, the first question is how 9arm actually wires this up. The answer is in qwen-agent's own SKILL.md. The core is a command called claude-9arm, an alias of claude --model qwen3.6-35b-a3b routed through his gateway. To hand off a job, you run it headless with -p:

But to keep it from falling apart mid-job, the SKILL.md hammers three points, and these three are the real reason the idea works, not the command itself.

• Write a prompt that stands on its own. The cheap model sees none of this conversation. Give it absolute paths to every file, say what to change and what "done" looks like, and never refer to "the file we discussed."
• Size it to the 128k context. Qwen holds far less than a top-tier model. Big jobs have to be sliced into chunks that each touch a bounded set of files, not the whole repo dumped in at once.
• Verify its output every time. Cheap buys you less reliability. Read the diff or run the test to confirm before you call it done.

The key point: you don't have to use Qwen at all. The idea is "the cheapest thing that can finish this job": a subagent set one model tier down, a model you run locally, or a short script with no AI in it. The claude-9arm mechanism is one way to do it, not a requirement.

The other half 9arm throws in is qwenchance, the skill that keeps long jobs from burning tokens in circles. Its logic is usable right away even without installing it: before each step, check three things. Are you re-reading the same file or retrying a dropped hypothesis, have you reasoned past a thousand words without acting, and is context getting tight? If any fire, break and hand off instead of letting the whole run melt into a loop.

And if you do want the full set? The repo recommends installing with npx skills add thananon/9arm-skills, which works for any agent. But same as before: you don't need the whole bundle. Read the two Qwen skills and write your own version that fits the setup you already run, and you'll get more out of it than copying it wholesale.

Part 4Straight talk about the repo, and how to use it

About the repo itself, plainly: it's small and personal, 6 skills, and the bucket layout is borrowed from Matt Pocock's repo without attribution. So its value isn't in taking the whole thing, it's in this one cost idea, which matches the lesson from the whole series: no repo is meant to be swallowed whole, just take the good part.

You don't even need Qwen to use it. The move is to look at the repetitive work you do every day and ask which of it doesn't need an expensive model. Renaming, reformatting, summarizing, hand those to something cheaper, and the bill eases off without the work getting worse.

This post is one layer in the 7-layer architecture of a production AI agent.