I Catalogued 1,000+ Open-Source Claude Agent Skills. Here's What the Ecosystem Actually Looks Like.

Abdullah Al-Kindi — Sun, 13 Sep 2026 09:53:59 +0000

Six months ago, finding a Claude agent skill meant opening fourteen GitHub tabs.

You'd start at Anthropic's own repository, then follow a link from someone's post to a community fork, then another fork of that fork. Half the skills had no description. A quarter were broken. And every one of them lived in a different folder structure, so you couldn't tell what a skill did without reading its SKILL.md line by line.

I got tired of it, so I indexed the whole thing. Over a thousand skills, pulled from Anthropic's public repositories and the largest community collections, then classified, described, and made downloadable from one page.

Here is what the data looked like once it was all in one place.

Most skills solve five problems, not a thousand

The long tail is real, but it is thinner than the raw count suggests. Cluster the skills by what they actually do and the vast majority fall into five buckets:

Document manipulation. Reading, generating and editing .docx, .pdf, .xlsx, .pptx. This is the single largest category, and it is not close. It is also the category where skills matter most, because these are formats where a model without procedural guidance produces output that is technically valid and visually broken.

Codebase navigation. Conventions, review checklists, framework-specific patterns. Skills here encode a team's taste, not a capability.

External tool orchestration. Wrappers and protocols around APIs, most of them now converging on MCP.

Content production in a fixed house style. Marketing copy, changelogs, release notes, documentation.

Data extraction and transformation. Scraping, parsing, reshaping.

If you are writing your first skill, you are almost certainly writing one of these five. Look at what exists before you start.

The description field is doing the heavy lifting

This was the most consequential thing I learned, and it has nothing to do with the skill's content.

A skill is loaded based on its description. That field is not documentation. It is a routing decision. The model reads it and decides, in that moment, whether this skill applies to the task in front of it.

Most of the skills I indexed get this wrong in one of two directions.

Too narrow, and the skill never fires:

description: Formats quarterly reports.

Too broad, and it fires on everything, crowding out skills that actually apply:

description: Helps with documents and files and data and analysis.

The ones that work name the trigger conditions explicitly: the file extensions, the verbs, the phrasings a user would actually type.

description: Use when creating, reading, or editing Word documents
  (.docx) or Word templates (.dotx). Triggers include mentions of
  "Word doc", ".docx", or requests for reports, memos, or letters as
  downloadable Word files. Do NOT use for PDFs or spreadsheets.

Notice the negative clause at the end. Telling the model when not to load a skill is as valuable as telling it when to. Roughly one skill in twelve in my index does this. Those are consistently the better-behaved ones.

Bundled scripts beat prose instructions

There are two ways to write a skill that manipulates files.

You can describe the procedure in prose and hope the model reconstructs the code correctly each time. Or you can ship a working script alongside the skill and have the instructions point at it.

The second approach wins on every axis that matters. It is deterministic, because the same script runs the same way every time. It consumes fewer tokens, because the model reads a one-line invocation instead of a forty-line explanation. And it is debuggable by a human, because the script is just a file you can run yourself.

The best skills in the index are thin. A short SKILL.md that establishes when to act and what the constraints are, plus a scripts directory doing the actual work. The worst are three thousand words of prose trying to talk a model through something a twenty-line Python file would handle exactly.

Progressive disclosure is the pattern nobody names

Context is the scarcest resource in any agent system. Every token spent on an unused instruction is a token not spent on the user's actual problem.

The well-built skills handle this in layers:

The description is always loaded. Keep it under about a hundred words.
The body of SKILL.md loads when the skill triggers. Keep it under five hundred lines.
Reference files load only when the body points to them.

That third layer is where the detail belongs: the edge cases, the format specifications, the long tables. A skill that front-loads everything into SKILL.md is paying a context tax on every single invocation for content it needs five percent of the time.

What I'd build differently now

Three things I would tell my six-months-ago self.

Write the failure mode first. Before describing what the skill should do, write down what goes wrong without it. If you cannot name a specific failure, the model probably does not need the skill.

Test the trigger separately from the content. These are two distinct failure modes. A skill can have flawless instructions that never load, and that is indistinguishable from having no skill at all. Test them apart.

Steal structure, not content. The folder layouts and disclosure patterns in mature skills are worth copying wholesale. The instructions inside them are specific to someone else's codebase and taste.

Why I put the index behind a free page

The Arabic-speaking developer community is large and growing fast, and almost none of this tooling reaches it. The documentation is in English. The community discussions are in English. The gap is not talent, it is access and discovery time.

So the library is free, it is in Arabic, every entry links back to its original source on GitHub, and it stays free. That is the whole business model, because there isn't one.

Abdullah Al-Kindi is the founder of Azhal, an independent digital product studio based in Saudi Arabia. He builds cross-platform apps with Flutter and Dart, deploys AI agents and automation workflows, and maintains a free open library of Claude agent skills for Arabic-speaking developers.