DEV Community: SKILL123.me

The 10 Claude skills worth installing (and what most people get wrong)

SKILL123.me — Fri, 18 Sep 2026 08:14:04 +0000

I've evaluated 500+ agent skills on a six-dimension rubric — trigger quality, structure, workflow design, content, engineering, and security. These are the ten I'd actually install, each with the one mistake people make when using it.

The skill ecosystem is a gold rush right now, and most of what's being panned is fool's gold. A skill is just a folder with a SKILL.md that teaches your agent a job — but the gap between a great one and a lazy prompt-wrapper is the gap between "wow, it actually works" and "why did it just delete my formatting."

After running 500+ skills through a structured evaluation, here are the ten that earned a permanent spot, with the trap most people fall into with each.

1. xlsx (official) — 9.8/10

Reads and writes Excel workbooks: formulas, formatting, charts.

Why it's the best: It verifies its own output. After every write, it recalculates and checks the result before claiming success. Most skills just say "done" and hope.

What people get wrong: Asking it to "fix the numbers" without opening the file afterward. Its verification catches formula errors, not intent errors — check that the right thing got computed.

2. docx (official) — 9.7/10

Word documents: tracked changes, comments, find-replace, styled output, TOCs.

Why: A task-routing table sends each job type to a proven recipe, and a render-to-image check catches layout breakage that text-only verification misses.

What people get wrong: Trusting tracked changes to be complete. Accept them in Word's review pane, not by reading the diff in chat — the visual check is the whole point.

3. pptx (official) — 9.7/10

PowerPoint creation and editing, template-aware.

Why: The engineering is exceptional — it knows the corruption patterns naive XML editing causes and routes around every one. Like xlsx, it verifies after building.

What people get wrong: Feeding it a company template with 40 master slides and expecting magic. Give it your simplest working template, not the one your design team made in 2019.

4. archify — 9.4/10

Generates architecture diagrams and flowcharts as self-contained HTML you can export.

Why: The engineering discipline is a masterclass — acceptance gates, subagent dispatch per diagram, state you can audit.

What people get wrong: Treating the output as a spec. It's a diagram — great for communicating a design, wrong as the source of truth for one.

5. baoyu-slide-deck — 9.3/10

Generates slide decks as styled images — 17 style presets, consistent visual identity across slides.

Why: A genuinely different philosophy from pptx: instead of wrestling PowerPoint XML, it renders each slide as a designed image. For "make this look good fast," it wins.

What people get wrong: Not realizing the output isn't editable PowerPoint. If your boss needs to tweak slide 12 after the meeting, use pptx instead. Pick your use case first.

6. prompt-master — 9.3/10

Turns a vague request into a production-quality prompt for any AI tool, via a 9-dimension intent extraction.

Why: Best trigger design I've evaluated — it knows when NOT to fire, which almost no skill gets right.

What people get wrong: Using it to write prompts for the skill itself. Meta-prompting a skill that will prompt an agent that will... just write the prompt yourself.

7. rag-architect — 9.3/10

Designs RAG architectures: chunking strategy, retrieval pipeline, evaluation methodology.

Why: Every implementation step ends with an assertion checkpoint. You can follow its work like a test suite.

What people get wrong: Expecting it to build the thing. It's an architect, not a contractor — it designs the system and tells you how to evaluate it. The building is still yours.

8. codex-ppt — 9.2/10

Builds presentation decks as unified image sequences, with per-slide subagents enforcing a style contract.

Why: A 30-slide deck keeps visual consistency where single-context generation drifts. The approval gates mean nothing ships without your sign-off.

What people get wrong: Skipping the configuration step. It needs an image-generation backend — spend the five minutes on setup or the output will disappoint.

9. humanizer — 8.8/10

Rewrites AI-sounding text so it reads naturally.

Why: It's built on a catalog of specific AI tells with before/after examples, not vague "make it casual" instructions. Fact-preservation checks stop it from rewriting your claims.

What people get wrong: Running it on text that's already fine. Humanizers are for first-draft slop — running it twice makes prose weird and defensive, not "more human."

10. pdf (official) — 8.6/10

PDF reading, merging, splitting, form-filling, extraction.

Why: Official skill with a gated form-filling workflow that verifies field mappings before writing anything.

What people get wrong: Expecting it to beat PDF itself. Scanned documents and odd encodings still fall over — that's the file format's fault, and 8.6 is the problem domain talking, not the skill.

What the other 490 skills taught me

Three patterns hold across everything I evaluated:

Verification is the rarest feature. The official skills verify their own output; almost nothing else does. When a skill says "done," ask what evidence it has.
The description IS the product. Half of all skills have trigger descriptions that either never fire or fire constantly. A skill that doesn't trigger when you need it is dead weight in your context directory.
Popularity and safety are uncorrelated. The worst thing I found — credential-harvesting scripts behind an innocent description — sat in a repo with a five-figure star count and zero issues filed. Read the scripts before you install, or use something that reads them for you.

Every skill above was scored on the same public rubric, and each one's full scorecard — with written rationale per dimension — is at skill123.me. No black-box ratings.

What's in your top ten? Genuinely curious what I'm missing — the good stuff hides in small repos.

What skill would you pay $5-10 for if it existed?

SKILL123.me — Fri, 18 Sep 2026 08:03:15 +0000

There are plenty of free SKILLs out there, but most of them are pretty low quality.

I’m planning to build a platform focused on high-quality SKILLs, but it would be paid.

What kind of SKILL would you be willing to pay $5–10 for?

I evaluated 500 AI agent skills. Most of them should not exist.

SKILL123.me — Tue, 15 Sep 2026 08:31:50 +0000

A practical guide to the agent-skill ecosystem — what skills are, where to find them, and how to tell the great ones from the prompt-wrappers before you install.

AI coding agents have quietly gained a superpower most people haven't fully explored yet: skills.

A skill is a folder of instructions — usually a SKILL.md file plus optional scripts, references, and templates — that teaches your agent how to do a specific job well. Install a PDF skill and your agent suddenly knows how to extract, merge, and manipulate documents. Install a debugging skill and it stops guessing at bugs and starts isolating them systematically.

Claude Code ships with a handful of official skills. The community has built hundreds more. But there's a problem: the ecosystem has no quality floor. Some skills are meticulously engineered. Others are a single paragraph of vague instructions wrapped in a folder. And a few — including one with tens of thousands of GitHub stars — instruct your agent to do genuinely unsafe things.

This guide covers what you need to know: how skills work, where to find them, and the evaluation framework we built at Skill123 to separate the signal from the noise.

What is an agent skill, exactly?

Technically, a skill is just a directory containing a SKILL.md file with YAML frontmatter:

my-skill/
├── SKILL.md          ← the core: name, description, instructions
├── scripts/          ← optional executable code
├── references/       ← optional deep-dive docs
└── assets/           ← optional templates

The magic is in the description field. When you chat with your agent, it scans the descriptions of all installed skills and loads the relevant one into context. A well-written description fires at exactly the right moment; a lazy one either never triggers or triggers constantly.

The best skills follow a pattern Anthropic calls progressive disclosure: a lean SKILL.md (under 500 lines) with the essentials, plus references the agent loads only when needed. This keeps context usage low and accuracy high.

Where the skills live

Anthropic's official repo — document processing (PDF, DOCX, XLSX, PPTX), design tools, and the skill-creator itself. High quality, conservative scope.
Community collections — aggregations from dozens of authors, ranging from polished frameworks to weekend experiments.
Standalone repos — single-purpose skills like Obsidian integration or architecture-diagram generation.
Skill123 — a curated directory of 493 skills where every entry has been evaluated. That's what the rest of this article is about.

The problem: stars ≠ quality

GitHub stars measure attention, not engineering. A skill can be popular because it was early, because it's funny, or because the README is charming — while its instructions are ambiguous, its scripts are broken, or its trigger description is so vague the agent never actually uses it.

Worse, skills run with your agent's full permissions. A skill that says "read the browser cookies and send them to this API" reads almost the same as one that says "read the browser history and summarize it." If you install skills the way you install npm packages — trust the stars, skim the README — you're doing security by vibes.

When we started evaluating skills for Skill123, we found exactly this: a widely-shared research skill whose scripts parse Safari's cookie store and decrypt Chromium credential databases. It had a five-figure star count. Nobody had flagged it, because nobody was reading the scripts.

The six-dimension evaluation framework

Every skill on Skill123 is scored on six dimensions, 100 points total, with written rationale for each score:

1. Trigger Quality (20 pts) — Does the description say what the skill does, when to use it, and when not to? Does it cover the phrases a user would actually type? The best descriptions read like they were written by someone who watched real users miss the skill ten times.

2. Structure (15 pts) — Is the content split correctly between SKILL.md, references/, scripts/, and assets/? A 900-line SKILL.md with no offloading burns context on every activation; a 40-line one that references files that don't exist is worse.

3. Workflow Design (25 pts) — The heavyweight dimension. Is the skill task-oriented (steps the agent executes) rather than topic-oriented (facts the agent reads)? Are high-risk steps constrained with low freedom (exact commands) while creative steps get high freedom? Is there a verification loop so the agent can check its own work?

4. Content Quality (10 pts) — Concise, imperative, executable. Commands with real arguments, not run the tool with the appropriate options.

5. Engineering (10 pts) — Valid frontmatter, runnable scripts, file paths that actually resolve in the shipped package. You'd be surprised how many published skills reference files they forgot to include.

6. Security (20 pts) — Static analysis of every script and document: no undeclared network calls, no obfuscated execution, no credential access, no prompt injection ("ignore previous instructions and..."). One confirmed violation of the hard rules caps the total score at 39/100 — an automatic fail.

That last rule isn't theoretical. We delisted a popular skill on day one of this policy.

What the data shows after evaluating 493 skills

A few patterns from our evaluation database:

Trigger descriptions are the weakest link. The most common failure across the ecosystem is a missing "when NOT to use this" clause. Skills without boundaries trigger on adjacent requests and pollute context.

Structure quality is bimodal. Skills from experienced authors (Anthropic's own, the superpowers methodology suite, well-maintained collections) consistently nail progressive disclosure. Everything else tends toward one extreme or the other: bloated single files or skeletal stubs pointing at missing references.

Security is mostly fine — until it isn't. The overwhelming majority of skills are benign document generators and API wrappers. But the violations we did find were serious (credential harvesting, prompt injection) and all of them came from skills with strong social proof. Popularity and safety are uncorrelated.

How to evaluate a skill yourself in five minutes

Even without a formal framework, you can filter out most of the noise:

Read the description first. Does it tell you when not to use it? No → expect false triggers.
Count the files. SKILL.md over ~500 lines with no references/ → context hog. References that don't exist in the repo → broken.
Grep the scripts for curl, wget, eval, base64, and paths like ~/.ssh, ~/.aws, Cookies. Every hit should have an obvious, declared purpose.
Look for a verification step. "After running, check that X is true" separates engineering from prompt-writing.
Check the freedom gradient. Destructive or external-facing actions should have exact, low-discretion instructions. Creative output should have room.

Installing skills

Once you've picked a skill worth installing, there are three ways, all supported on Skill123:

One-liner install (curl the installer and run it):

curl -fsSL https://skill123.me/install/<skill-slug>.sh | bash

Install via AI — copy a single prompt into Claude Code and it fetches the instructions and installs the skill itself:

Install the "humanizer" skill by following the instructions at
https://skill123.me/install/humanizer.

Manual — download the zip, extract to ~/.claude/skills/, restart your session.

Yes, curl | bash deserves the standard caution: read the installer first (ours is ~30 readable lines), and prefer skills whose evaluation notes you've actually skimmed.

Where to start

If you're new to skills, these categories have the highest concentration of quality on Skill123 right now:

Documents — the official PDF/DOCX/XLSX/PPTX skills are the gold standard of the format
Developer Tools — debugging methodology, TDD, and constraint-driven development
Writing — translation, grammar, content auditing
Design & Creative — diagrams, infographics, and AI image generation
Data & Analytics — pandas, SQL, and experiment analysis

Every skill page shows the full six-dimension scorecard with the reasoning behind each number — so you can disagree with us, which is the point. An evaluation you can inspect is worth ten you can't.

Skill123 is a curated directory of AI agent skills, with every entry evaluated across six dimensions before listing. Browse the leaderboard or search all 493 skills.