Awesome Claude Skills (1,000+ skills) — curated production skills for Claude Code. Standardize agent capabilities without rebuilding Slack/RAG/automation.
Awesome Claude Skills — 1,000+ Production Skills: The Fastest Way to Standardize Agent Capabilities
Awesome Claude Skills by ComposioHQ is a curated directory of 1,000+ production-ready skills for Claude Code — the fastest way to standardize agent capabilities without building from scratch. Trending in May 2026 alongside mattpocock/skills (+28k stars in a week), it signals that the skills framework has commoditized: you no longer prompt-engineer each capability, you install it.
I curate skills for my Junagadh team the way a CTO curates a design system. Every new agent project used to start with weeks of prompt engineering, tool definitions, and CLAUDE.md debates. This collection is the starting block that saves those weeks — we install, audit, and compose instead of inventing.
Who this is for: Founders, AI leads, and teams standardizing Claude Code agents who want proven, reusable skills instead of rebuilding Slack, Notion, RAG, and automation patterns from zero for every project.
The Problem: Every Team Rebuilds the Same Agent Skills from Scratch
When I onboarded two junior engineers in Junagadh onto Claude Code agent work in early 2026, I watched the same waste I had seen for months: we were rebuilding identical capabilities in every project. One project needed a Slack notification skill, another needed a Notion reader, a third needed a RAG query tool — and each was prompt-engineered from scratch, with different schemas, different error handling, and different CLAUDE.md conventions.
This is the hidden tax on agent teams:
1. Prompt engineering does not scale. A well-crafted skill — tool definition, system prompt, examples, error handling — takes 1-3 days to get right. Multiply by 20 common capabilities (browser automation, RAG, MCP wiring, deployment, scraping) and you have 40-60 days of duplicated work before your agent does anything useful. And each skill is bespoke, so knowledge does not transfer between projects or engineers.
2. Without standards, agents drift. When each engineer writes their own CLAUDE.md instructions for the same task ("how to query Postgres" or "how to handle OTPs"), agents behave inconsistently. One agent commits without tests, another asks for approval on every select. The absence of a shared skill contract is the absence of engineering discipline.
3. Discovery is broken. There are now tens of thousands of Claude skills scattered across GitHub repos, gists, and blog posts. Finding a production-tested skill for "deploy to Hostinger via SSH" or "ingest PDF to pgvector" requires hours of search and guesswork. Most teams give up and build a mediocre version themselves.
Awesome Claude Skills solves this as a curated, production-ready directory. ComposioHQ — the team behind the Composio MCP platform — has aggregated and vetted 1,000+ skills with consistent structure, so you can find, install, and compose instead of invent.
Why 1,000+ Skills and +28k Stars Signal Commoditization
In May 2026, two signals converged: Awesome Claude Skills crossed 1,000+ curated skills, and mattpocock/skills gained +28k stars in a single week. Independent collections from Superpowers and Browserbase are trending simultaneously. This is not hype — it is commoditization.
When a framework commoditizes, the winning move is not to build more framework — it is to curate and compose. Just as npm commoditized JavaScript utilities and Tailwind commoditized CSS, the skills directory commoditizes agent capabilities. The teams that win are those that standardize on a shared skill library and focus their custom work where it is truly differentiating — their domain logic, not Slack integration #47.
For my team, the directive is clear: we do not build a skill that exists in the directory and passes our audit. We install it, pin it, and invest our time in Gujarat SME domain skills (GST, GeM, Tally) that no generic directory will ever contain. This is the same taste profile I enforce in my MCP Agent Builder blueprint and OpenClaw personal assistant pattern.
Architecture: How a Skills Directory Turns into a Team Standard
A skill is not a prompt snippet. It is a contract: a tool definition, system instructions, examples, and constraints that Claude Code loads into context via CLAUDE.md and the skills framework. Awesome Claude Skills provides these contracts pre-built and curated.
graph TD
A[Awesome Claude Skills - 1000+ Curated Skills] --> B{Discovery & Audit}
B --> C[Category - Automation RAG Browser MCP Deployment]
C --> D[Skill Selection - Star Vibe Curation]
D --> E[Install to Project - CLAUDE.md + skills/]
E --> F[Claude Code Runtime]
F --> G[Agent Composes Skills - RAG + Browser + Slack]
G --> H[Project Delivery - Faster Stable]
E --> I[Team Standard - Shared Skill Library]
I --> J[Junagadh Team - Same Skills Same Behavior]
B --> K[Quality Gate - My 5-Axis Audit]
K -->|Pass| D
K -->|Fail| L[Build Custom or Fork]
G --> M[Observability - Cost Trace Audit]
subgraph Curation Layer
A
B
K
end
subgraph Standardization Layer
E
I
J
end
subgraph Execution Layer
F
G
M
end
How this maps to my Junagadh workflow:
1. Discovery via Curation, Not Search: Instead of searching GitHub for "claude slack skill", I browse Awesome Claude Skills by category — Automation, RAG, Browser, MCP, Deployment. Each skill has a consistent README, install command, and CLAUDE.md snippet. The directory does the first filter so I do not have to.
2. Audit Before Install: Every skill from the directory goes through my 5-axis audit (see Quality Audit below). If a skill fails — e.g., it exfiltrates data or lacks error handling — I fork and harden or build custom. About 30% of directory skills pass without modification; 50% need hardening; 20% are rejected. The directory saves discovery time, not diligence.
3. Install as Team Standard: Approved skills are pinned in our internal skills repo with version and install source. CLAUDE.md at the project root references them declaratively. When a new engineer joins, they read CLAUDE.md and have the team's entire capability library — not folklore, a manifest.
4. Compose, Don't Rebuild: Real agent value comes from composing skills: RAG (from directory) + Browser-Use (from directory) + custom GST logic (our IP) + Slack notification (from directory). The directory provides the commodity layers so we invest where we are differentiated.
5. Observability Across Skills: Because skills share conventions, cost and trace logging can be uniform. I wire Langfuse across all skills so I can see which skill burns tokens and which fails most — impossible when every skill is bespoke.
This architecture is not about the directory — it is about turning the directory into an engineering standard. The directory is the starting block; your CLAUDE.md and audit discipline are the taste profile.
Implementation: From Directory to Production CLAUDE.md in One Afternoon
All examples use Claude Code 1.0+, skills framework, and the Awesome Claude Skills directory. No additional install beyond claude-code required.
1. Discover, Audit, and Install — The Curation Loop
This is how I evaluate a skill from the directory before it touches a client project. The example uses a representative Slack notification skill — the pattern is identical for any of the 1,000+.
# 1. Browse the directory — find candidates by category
# https://github.com/ComposioHQ/awesome-claude-skills
# Categories: automation, browser, RAG, MCP, deployment, scraping, etc.
# 2. Clone and inspect — never install blind
git clone https://github.com/ComposioHQ/awesome-claude-skills /tmp/awesome-claude
ls /tmp/awesome-claude/skills/slack-notify/
cat /tmp/awesome-claude/skills/slack-notify/SKILL.md
cat /tmp/awesome-claude/skills/slack-notify/CLAUDE_SNIPPET.md
# 3. My audit checklist — run before install
# - Does SKILL.md define tool schema with Pydantic/Zod? (no loose prompts)
# - Does it handle errors and rate limits explicitly?
# - Does it log actions for audit?
# - Does it require secrets via env, not hardcoded?
# If any answer is no -> fork and harden before installing
# 4. Install to project — pin version
mkdir -p ./skills/slack-notify
cp -r /tmp/awesome-claude/skills/slack-notify/* ./skills/slack-notify/
echo "awesome-claude-skills/slack-notify @ commit abc1234 — audited 2026-05-15" >> ./skills/ATTRIBUTION.md
Curation rule I enforce: Every installed skill has an entry in ATTRIBUTION.md with source commit, audit date, and auditor name. This is how we keep taste profile and provenance when the directory has 1,000+ options. Without attribution, the library becomes unmanageable in 30 days.
2. CLAUDE.md — The Starting Block That Saves Weeks
This is the actual starting block pattern from my Junagadh team. It composes directory skills into a team standard. New projects copy this CLAUDE.md and are productive in hours, not weeks.
# CLAUDE.md — SaaS Next Agent Standard (Junagadh)
# Source: Awesome Claude Skills + Team Custom — audited 2026-05-15
## Core Skills (from awesome-claude-skills — pinned)
- `slack-notify` — Post to Slack via webhook, env SLACK_WEBHOOK_URL, rate limit 1msg/sec
- `notion-reader` — Read Notion databases, env NOTION_TOKEN, read-only
- `browser-use` — Web automation via Browser-Use, requires human approval for Submit/File/Pay
- `rag-query` — Query local RAG via RAG-Anything, citations required, abstain if no source
## Custom Skills (team IP — not in directory)
- `gst-extract` — GST portal extraction, OTP via Telegram, Pydantic GSTExtraction output
- `gem-tracker` — GeM order tracking, Browserbase fleet, JSON to Postgres
## Global Rules
- Never commit without `npm run test` and `ruff check` passing
- Never hardcode secrets — env only, verified via `env | grep -v PASS`
- Every answer from rag-query must include citations or explicit "Not found"
- Every browser-use action on financial portals logs screenshot + action to ./logs/
- Cost guard: max 25 steps per agent loop, log tokens to Langfuse
## Skill Install Policy
- Do not install a skill that exists in awesome-claude-skills without audit
- Attribute every skill in ./skills/ATTRIBUTION.md with source commit + audit date
- Prefer directory skill over custom build — custom only for GST/GeM/Tally domain
Why this saves weeks: A new engineer does not debate "how should we do Slack notifications" — they read the standard and use slack-notify as defined. A new project does not prompt-engineer RAG querying — it reuses rag-query with citation enforcement already baked in. The directory provides the raw material; CLAUDE.md makes it a team contract.
For the full agent wiring, see MCP Agent Builder, and for the personal assistant pattern see OpenClaw. For how this fits our search strategy, see SEO & AEO services.
3. Composing Directory Skills with Custom Domain Logic
The real power is composition — directory skills for commodity, custom skills for IP. This Python agent composes a directory RAG skill with our custom GST extraction skill.
# pip install anthropic mcp
# Claude Code loads skills from CLAUDE.md — this is the orchestration layer
import asyncio
from claude_code import ClaudeAgent # Illustrative — actual API via Claude Code CLI/SDK
agent = ClaudeAgent(
claude_md="./CLAUDE.md", # Loads all skills defined above
model="claude-3-5-sonnet-20241022",
)
# Task that composes directory + custom skills automatically
# No manual wiring — CLAUDE.md declarative binding handles it
task = """
1. Use rag-query to answer: What is the credit note procedure for XT-42 returns?
- If not found in SOPs, say so — do not hallucinate.
2. Use gem-tracker to check pending GeM orders for last 7 days.
3. Post a summary of both to Slack via slack-notify to #ops-daily.
4. Log all actions to ./logs/composed_run.json
"""
result = asyncio.run(agent.run(task))
print(result.summary)
# Citations from rag-query + JSON from gem-tracker + Slack confirmation
# All skills share cost tracing via Langfuse
Composition discipline: Directory skills handle 70% of the task (RAG, Slack, browser). Custom skills handle 30% (GST/GeM domain parsing). If you invert this — building custom Slack or RAG — you are wasting the directory's value. My rule: if the directory skill passes audit, use it. Build only what the directory will never contain.
Quality Audit: Can You Trust a 1,000-Skill Directory?
I audit the directory as a supply chain and each skill individually. Here is my May 2026 assessment.
| Axis | Verdict | Evidence |
|---|---|---|
| Curation Quality | 7.5/10 | 1,000+ skills is comprehensive but uneven. Top 20% (Slack, Notion, RAG, browser) are production-grade with Pydantic schemas. Bottom 30% are thin wrappers with loose prompts — require hardening. The signal is in stars and recent commits, not just inclusion. |
| Supply Chain Risk | 7/10 | As with any awesome-list, inclusion is not endorsement. A skill can exfiltrate secrets if you install blind. Mitigation: never install without reading SKILL.md and CLAUDE_SNIPPET.md, and pin to a commit hash, not main. |
| Standardization Value | 9/10 | This is the category killer. Before the directory, our CLAUDE.md files diverged within a week. After standardizing on directory skills as the base, drift is measurable and manageable. The 9 is for the pattern, not every skill. |
| Composability | 8/10 | Skills that follow the directory's convention (tool schema + examples + error handling) compose cleanly. Skills that are just a prompt block do not — they require wrapping. Prefer skills with explicit tool definitions. |
| Maintenance | 7/10 | 1,000 skills = inevitable staleness. Check last commit date — skills with no commits since Jan 2026 are likely broken against Claude Code 1.0+. Pin and test in CI; do not assume freshness. |
My install policy:
- Only install skills with a
SKILL.mdthat defines a tool schema, not just a prompt. - Pin to a commit hash and record in
ATTRIBUTION.md— never trackmain. - Run the skill in a sandbox with mock secrets first — verify it does not log secrets.
- Schedule monthly
skills audit— re-check each installed skill against the directory for updates and CVEs.
For the broader agent supply chain, see my MCP Agent Builder and SEO & AEO for how skill content maps to discoverability.
Results: What a Shared Skill Library Actually Returns
Before standardizing (Jan 2026): Each new agent project spent 8-12 days on skill prompt engineering and CLAUDE.md debates. Onboarding a new engineer took 3 weeks to be productive on agents. Skill quality varied wildly between projects.
After standardizing on Awesome Claude Skills as the base (Mar-May 2026): New project scaffold time fell to 2-3 days — copy CLAUDE.md standard, install pinned directory skills, add custom domain skill. Onboarding time fell to 5 days — the standard is the documentation. Support load fell because agents behave consistently — "how does RAG querying work" has one answer, not five.
Measured: Across 4 agent projects in 60 days, we saved an estimated 28 engineering days by installing 11 directory skills instead of building them. At our blended rate, that is ~₹4.2L saved — and more importantly, 28 days we spent on GST/GeM domain logic that actually differentiates our SME offering, not on rebuilding Slack integration.
Compared to alternatives: mattpocock/skills (+28k week) is excellent for TypeScript-forward teams and more opinionated on DX; Superpowers and Browserbase skills are more narrowly scoped (browser + deployment). Awesome Claude Skills is the broadest production-ready base — it is the npm to their focused frameworks. We use it as the base and pull from the others where they are stronger.
The lesson is not about this directory — it is about the commoditization it represents. Skills are no longer craft, they are inventory. Curate inventory well and you ship faster than teams still hand-forging each skill.
Frequently Asked Questions
Should I use Awesome Claude Skills or mattpocock/skills or Superpowers?
They are complementary, not mutually exclusive. Awesome Claude Skills (1,000+ skills, ComposioHQ) is the broadest production-ready directory — best as your base. mattpocock/skills is TypeScript-forward and more opinionated on DX — excellent if your stack is TS-heavy (+28k week signals strong DX fit). Superpowers and Browserbase are narrower (browser automation, deployment) but deeper in their niches. My pattern: base on Awesome Claude Skills, pull best-in-class from the others where they are deeper, and standardize all via one CLAUDE.md.
How do I prevent skill sprawl when there are 1,000+ options?
Governance, not more choice. Enforce a CLAUDE.md standard that lists approved skills with pinned commits in ATTRIBUTION.md. New skills require an audit and PR approval. My team allows 8-12 approved skills total — everything else is rejected or forked as custom domain skill. Without a gate, 1,000 options become 1,000 inconsistencies. With a gate, they become a curated library.
Are directory skills production-ready or do they need hardening?
About 30% are production-ready as-is (those with Pydantic/Zod schemas, error handling, and recent commits). 50% need hardening — add rate limits, secret handling, and audit logging. 20% are too thin to use — treat as inspiration, not installable code. The directory saves discovery, not diligence. Always read SKILL.md and test in sandbox before wiring to client data.
How does this relate to MCP servers and my existing agent builder setup?
Skills and MCP servers are complementary layers. A skill is a capability contract (tool definition + instructions) that Claude Code loads; an MCP server is a runtime tool provider that exposes tools to the agent. Many Awesome Claude Skills wrap MCP servers (e.g., Notion, Slack, Postgres MCP). See my MCP Agent Builder for wiring MCP servers and OpenClaw for the personal assistant composition pattern — skills are the contracts, MCP is the execution.
Bottom Line
Awesome Claude Skills at 1,000+ production skills is not a list to browse — it is infrastructure to standardize on. If your team still prompt-engineers Slack, RAG, and browser automation from scratch for every Claude Code project, you are burning weeks that a curated directory has already solved. Install from the directory, audit hard, pin to commits, compose via a shared CLAUDE.md, and spend your custom effort where no directory will ever compete — your domain. That is how a Junagadh team ships like a 10x team.
Curated by Deepak Bagada — Leading AI Expert, founder SaaS Next, Junagadh Gujarat. I curate skills for our team so engineers compose instead of reinvent — weeks saved, drift eliminated. Need help standardizing your agent stack? See MCP Agent Builder and SEO & AEO.