skillit
quintonwall/skillit
A guide for creating well optimized Claude Code skills that sizzle.
Instalação
npx convez-ai quintonwall/skillit1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
README
A tradução para o português deste README ainda está na fila.
skillit 🍳
Make your skills sizzle.
skillit is a Claude Code plugin for founders who need to turn an idea into a working app fast, on a
tight budget. It teaches you to build skills — reusable leverage that speeds up your product work — and makes
sure they're lean enough to run all day without eating your runway. It teaches the structure, scaffolds it
for you, and scores what you built.
Why
skillit helps you build skills that are lean enough to run constantly and fast enough to ship, test, and
throw away. It bakes in the discipline from Anthropic's
prompting best practices
and Quinton Wall's
token-efficient skills post,
and makes you measure the result with the native /context and /cost commands. TL;DR: Less tokens spent = more runway for you to ship amazing products.
Installation
skillit is a Claude Code plugin. You cannot use it in the Claude Desktop app.
From the marketplace (recommended)
Add this repo as a marketplace, then install the plugin from inside Claude Code:
/plugin marketplace add quintonwall/skillit
/plugin install skillit@skillit
Update later with /plugin marketplace update skillit.
Locally (for development)
1. Clone the repo:
git clone https://github.com/quintonwall/skillit.git
2. Launch the Claude Code CLI pointed at the checkout. Pass the plugin directory with --plugin-dir:
claude --plugin-dir /path/to/skillit
If you're already inside the cloned folder, . works too:
claude --plugin-dir .
A local --plugin-dir copy takes precedence over a same-named marketplace install for that session, so you
can safely test changes even if you also have skillit installed from the marketplace.
There is no
/plugin-dirslash command — local loading is the--plugin-dirlaunch flag only.
Verify it loaded
Whichever route you used, confirm the plugin is live:
/skillit:verify
If it loaded correctly, Claude recognizes the skill-builder skill plus the /skillit:skill-new,
/skillit:skill-validate, /skillit:skill-audit, and /skillit:skill-optimize commands, and you'll get a
confirmation message. If nothing happens,
re-check the --plugin-dir path (or run /reload-plugins) and that you launched from the right directory.
Quickstart
Just talk to Claude, and the skill-builder teacher walks you through it.
Here's a complete run, from idea to a shipped skill. (Numbers below are illustrative.)
Testing locally? Launch with
claude --plugin-dir .(see Locally (for development)), and run/reload-pluginsafter any edit to a skill, command, or hook so your changes take effect without restarting.
1. Ask for what you want.
You: Help me build a skill that drafts release notes from our git log.
2. skillit baselines your cost, then asks the three things that shape a lean skill.
skillit: Let's get you a lean, shippable one. Run /context first so we have a
baseline to compare against. Then, three quick questions:
• Capability — in one sentence, what does it do?
• Trigger — when should I reach for it?
• Tools — what does it actually need? (so we scope allowed-tools)
You: /context
→ Skills: 1.2k tokens always-on
You: It writes release notes from commits since the last tag. Use it when I'm
cutting a release. It needs to run git and write a file.
3. It scaffolds the 3-tier structure (this is what /skillit:skill-new does):
skillit: Running /skillit:skill-new …
Created skills/release-notes/
├── SKILL.md ← frontmatter + workflow
└── references/ ← deep detail, loaded only when needed
4. It drafts the frontmatter with you — the highest-leverage part — and shows the trade-off.
skillit: The description loads in every session, so tight wins.
✗ "Use when the user says 'cut a release', 'release notes',
'changelog', 'tag a version', 'ship it'…"
✓ "Draft release notes from git commits since the last tag.
Use when the user is cutting a release."
The model routes on meaning, so the phrase list just burns tokens. OK?
You: yes
5. It builds the body with you, keeping it to the workflow (find the last tag → collect commits →
group them → write the notes) and pushing anything bulky into references/.
6. Validate and re-measure before shipping.
You: /skillit:skill-validate
skillit: Scorecard — release-notes
Description quality ...... 2/2
Body size & focus ........ 2/2
Progressive disclosure ... 2/2
Tool scoping ............. 2/2 (allowed-tools: Bash, Write)
Frontmatter validity ..... 2/2
Prompting craft .......... 2/2
Grade: 12/12 — Sizzling 🍳
You: /context → Skills: 1.5k tokens (+0.3k vs baseline)
You: /cost → this session: $0.04
That +0.3k always-on is the whole point: a skill lean enough to run all day without denting runway.
You're done — next time you say "I'm cutting a release," the skill fires automatically.
Optimize an existing skill (or all of them)
You don't have to start from an idea. If you already have skills — one you wrote, one you inherited, or a whole folder of them — skillit will look at them and make them lean.
One skill
Just ask. The skill-builder teacher triggers on "improve" and "optimize," so any of these work:
You: Look at my blog-writer skill and optimize it.
You: This SKILL.md feels heavy — can you trim it?
Or point the scorer straight at it to get the graded scorecard and a prioritized fix list:
You: /skillit:skill-validate skills/blog-writer
skillit: Scorecard — blog-writer
Description quality ...... 1/2 (3 sentences, includes a trigger-phrase list)
Body size & focus ........ 1/2 (210 lines — style guide belongs in references/)
Progressive disclosure ... 0/2 (no references/; everything inline)
Tool scoping ............. 2/2 (allowed-tools: Read, Write)
Frontmatter validity ..... 2/2
Prompting craft .......... 2/2
Grade: 8/12 — Warming up
Top fixes: 1) cut the phrase list from the description 2) move the
style guide into references/style.md and link to it 3) …
Then hand the fixes back to the teacher — "apply those fixes" — and it edits the skill with you, one
change at a time, highest-leverage first (description → body → runtime). Re-run /context and /cost to
see the savings.
Every skill in the project
To see all your skills at once — and the total always-on cost they add to every session — run the audit:
You: /skillit:skill-audit
skillit: Skill Grade Always-on Body Top fix
────────────────────────────────────────────────────────────────
blog-writer 8/12 412 chars 210 ln Cut phrase list from description
changelog 9/12 280 chars 90 ln Move examples into references/
release-notes 12/12 140 chars 42 ln —
────────────────────────────────────────────────────────────────
Combined always-on: ~832 chars across 3 skills.
Biggest offender: blog-writer. Fix it first.
skill-audit globs every SKILL.md in the project, scores each one in parallel (off your main context),
and ranks them worst-first so you know where to spend your time. From there, just tell skillit which to fix:
You: Optimize blog-writer and changelog.
skillit walks each one through the same trim → validate → re-measure loop, so a whole folder of skills gets lean without you scoring them by hand.
Structure, not output quality. skillit's optimization is about token footprint and structure — is it lean? For is the output still good? after trimming, hand the skill to Anthropic's
/skill-creatorto benchmark behavior (see below).
Not interested in learning? No problem — skillit can do the work for you
Everything above teaches as it goes: skillit narrates each principle so you come away able to author skills
yourself. That's the default, and it's the point. But sometimes you don't want a lesson — you want the skill
fixed and your afternoon back. That's what /skillit:skill-optimize is for. It scores, applies the fixes
directly to the files, and hands you a diff instead of a walkthrough:
You: /skillit:skill-optimize skills/blog-writer
skillit: blog-writer
Grade 8/12 → 12/12
Always-on 412 → 140 chars (-272)
Body 210 → 44 lines (moved style guide → references/style.md)
Changes • rewrote description (dropped 9-phrase trigger list)
• extracted style guide + examples to references/
• scoped allowed-tools: Read, Write
Review with `git diff`, then run /context and /cost to confirm the savings.
Point it at one skill, a directory, or --all to optimize every skill in the project in one shot:
You: /skillit:skill-optimize --all
It edits in place and leans on git as the safety net, so review the diff before committing. Want the why
behind a change? Ask skill-builder — that's the teaching mode. skill-optimize is the do-it-for-me mode.
What's inside
| Component | What it does |
|---|---|
skill-builder skill | A patient teacher that guides you idea → validated skill, one concept at a time, and answers questions as you go. Trigger it by asking to build, improve, or learn about a skill. |
/skillit:skill-new | Scaffolds a best-practice 3-tier skill from your idea. |
/skillit:skill-validate | Scores one skill against the rubric (via the skill-scorer subagent) and lists prioritized fixes. |
/skillit:skill-audit | Scores every skill in your project at once and returns one ranked table, worst-offender first, with the combined always-on token footprint. |
/skillit:skill-optimize | Applies the fixes for you — scores a skill (or all of them), edits in place, and reports a diff instead of teaching. The do-it-for-me counterpart to skill-builder. |
skill-scorer agent | Does the heavy scoring off your main context, then returns a compact scorecard. |
references/ | The durable knowledge: anatomy, frontmatter, token-optimization, prompting, rubric. |
| hook | A cheap nudge to run /skillit:skill-validate after you edit a SKILL.md. No model call. |
How skillit relates to the official skill-creator
skill-creator is Anthropic's lifecycle and evaluation
toolkit — Create / Eval / Improve / Benchmark, with agents that run a skill against eval prompts, grade its
outputs, A/B-compare versions, and benchmark with statistical confidence. It answers "does this skill
produce good output, and which version wins?"
skillit deliberately covers the two things skill-creator leaves open:
- Teaching the why — a patient, ask-anything tutor for someone learning to author skills, not a mode-driven power tool.
- Token & structure efficiency — skill-creator's scope doesn't include token optimization; that's
skillit's whole point (
/context,/cost, and the structural scorecard).
They're complementary, on different axes: skillit validates cost and structure (is it lean?), skill-creator validates behavior (is the output good?).
Handoff: build and trim your skill with skillit, then reach for /skill-creator to benchmark its
output quality once it's structurally sound.
Design principle
skillit measures before it optimizes and never duplicates state — the scoring rubric lives in exactly one
place (references/rubric.md), shared by the /skillit:skill-validate command and the skill-scorer agent.