Claude Code Skills Directory: Every Official Skill Repo I Use, From React to Rust

How Claude Code skills work (two minutes)

A skill is a directory containing a SKILL.md file. The top of that file has a name and a description in YAML frontmatter, and the body has the instructions. It can also carry extra reference files and scripts.

The clever part is that skills load in stages, which Anthropic's Agent Skills docs call progressive disclosure:

• Level 1, always loaded: just the name and description, roughly 100 tokens per skill. This is how Claude knows the skill exists.
• Level 2, loaded when relevant: the SKILL.md body, under 5k tokens, read only when your request matches the description.
• Level 3, loaded on demand: reference files and scripts. A script's output enters the context, not its source code.

So you can install a lot of skills without filling the context window. The description is what decides whether a skill fires, which is why good skill authors write descriptions like "Use when the user mentions X, Y or Z."

Claude Code looks for skills in two places: ~/.claude/skills/ for personal skills and .claude/skills/ inside a project. Skills can also come bundled inside Claude Code plugins.

Installing skills: the three commands you need

Most repositories in this post support one or more of these:

# 1. The open skills CLI from Vercel Labs. Works for any GitHub repo with SKILL.md files.
npx skills add vercel-labs/agent-skills
npx skills add supabase/agent-skills --skill supabase

# 2. Claude Code plugin marketplaces (run inside Claude Code)
/plugin marketplace add anthropics/skills
/plugin install example-skills@anthropic-agent-skills

# 3. Plugins from the official Claude Code marketplace
claude plugin install stripe@claude-plugins-official

The npx skills CLI is the one I use most because it takes any repo, and you can pick single skills with --skill instead of installing a whole collection. Each repository's README lists its preferred command, and I've noted the official ones below.

If you want the bigger picture of how skills sit inside an agent (the loop, the tools, the permissions), I covered that in agent harnessing. And if you're curious what happens when you hand Claude a pile of growth skills and let it run a real site, that was this experiment.

Official vs community, and why it matters

Every entry below is marked. Official means the repository is owned by the company or project behind the tool (Vercel, Stripe, Supabase, Expo, Docker and so on). Community means a developer or team outside that company wrote it.

Official skills track the product: when Next.js ships a new caching model, the Next.js skills change with it. Community skills can be excellent (Emil Kowalski's animation skills are the best in this whole list), but they move at the speed of one maintainer. Where no official skill exists for a tool, I've said so instead of pretending.

One safety note before the list. Skills can include scripts, and an agent will run them. Read the SKILL.md and any scripts/ folder before installing a community skill, the same way you'd read a shell script before piping it into bash.

1. Design, UI and UX skills

This is the category that changes output the most. Without a design skill, Claude produces the same safe layout every time: centered hero, three feature cards, purple gradient. With one, it makes deliberate choices about type, spacing and hierarchy.

anthropics/skills (official, Anthropic)

• frontend-design: guidance for distinctive, intentional visual design. It pushes Claude toward an actual aesthetic direction and typography choices that don't look templated. Use it whenever you're building a new page or reshaping an existing one.
• web-artifacts-builder: tooling for multi-component HTML artifacts built with React, Tailwind CSS and shadcn/ui, for when a single file isn't enough.
• theme-factory: ten preset color and font themes you can apply to slides, docs or landing pages.
• canvas-design and algorithmic-art: posters and static visuals, and generative art in p5.js with seeded randomness.

vercel-labs/agent-skills (official, Vercel)

• web-design-guidelines: reviews your UI code against Vercel's Web Interface Guidelines. Trigger it with "review my UI", "check accessibility" or "audit design". This is my default pre-ship check.
• writing-guidelines: the same idea for docs and UI copy, checking voice and tone against a writing handbook.

nextlevelbuilder/ui-ux-pro-max-skill (community)

• ui-ux-pro-max: a large UI/UX knowledge skill for web, mobile and desktop, covering pages, components, design systems, accessibility, interaction and responsive layout. It's the heavyweight option when you want Claude to reason about design rather than just apply a style.
• The same repo ships design-system (three-layer tokens: primitive, semantic, component), ui-styling (shadcn/ui plus Tailwind), brand, banner-design and slides.
• Install with /plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill, then /plugin install ui-ux-pro-max@ui-ux-pro-max-skill.

shadcn-ui/ui (official, shadcn)

• shadcn: manages shadcn components and projects (adding, searching, fixing, debugging, styling and composing UI, including chat interfaces), with component docs and usage examples. It lives inside the main shadcn repository.
• migrate-radix-to-base: moves a project or single components from Radix UI primitives to Base UI.

If you're collecting shadcn extensions to pair with this, my list of cool shadcn libraries is still the one I point people to.

Tailwind CSS: I couldn't find an official Tailwind Labs skill repository. The two I'd use are ui-styling above and the community tailwind-design-system from wshobson/agents, which targets Tailwind v4 design tokens and component libraries.

Use this category when: you're starting a landing page, building a dashboard, or about to ship a UI you haven't had a designer look at.

2. React, Next.js, Vite, TanStack and Astro

Framework skills are where official repos matter most, because frameworks change faster than model training data.

React

There's no skill from the React team itself. The reference is Vercel's:

• react-best-practices (official, Vercel): React and Next.js performance guidelines from Vercel Engineering. It's meant to load whenever Claude writes, reviews or refactors React code. If you install one skill from this whole post, make it this one.
• composition-patterns (official, Vercel): composition patterns for components drowning in boolean props, for compound components and for reusable component APIs.
• react-view-transitions (official, Vercel): React's View Transition API (<ViewTransition>, addTransitionType and the CSS pseudo-elements). More on this in the animation section.

Prepping for interviews alongside this? The 50 React interview questions post covers the same ground from the other side.

Next.js

The Next.js team keeps skills inside the main repository, under skills/ on the canary branch (official, Vercel):

• next-dev-loop: verifies that a change works in a running app, not just that it compiles. It combines Next.js's built-in /_next/mcp endpoint with a browser.
• next-bundle-optimizer: audits and reduces initial-load work, such as oversized client bundles and duplicate dependencies.
• next-cache-components-adoption and next-cache-components-optimizer: turn on Cache Components, fix the blocking routes it surfaces, then optimize what renders instantly.
• next-partial-prefetching-adoption and next-partial-prefetching-optimizer: the same two-step flow for Partial Prefetching.

These are the skills that know about features newer than any model's training cutoff. The bundle optimizer pairs well with my rant about why websites are slow. For starter projects to try them on, see the free Next.js boilerplates list.

Vercel also ships deployment and cost skills in vercel-labs/agent-skills: deploy-to-vercel, vercel-cli-with-tokens and vercel-optimize, which pulls real usage metrics before suggesting cost and performance fixes.

Vite and Vitest

• antfu/skills (community, by Anthony Fu of the Vite and Vitest core teams): vite covers vite.config.ts, the plugin API, SSR and the Vite 8 Rolldown migration. vitest covers writing tests, mocking, coverage and fixtures. The repo also has skills for Vue, Nuxt, Pinia, UnoCSS, VitePress and pnpm.

TanStack

• DeckardGer/tanstack-agent-skills (community): four skills, tanstack-query, tanstack-router, tanstack-start and tanstack-integration, which covers Query, Router and Start working together across SSR and caching.
• TanStack's own approach is different: its Intent project is tooling for libraries to generate and ship skills alongside their npm packages, with meta-skills for generating skills and checking whether they've gone stale. Worth watching, because "the package ships its own skill" is probably where this all ends up.
• If you use Clerk with TanStack Start, clerk-tanstack-patterns is official.

Astro

• astrolicious/agent-skills (community): a single astro skill for components and pages, SSR adapters, content collections, static deploys and the CLI. I didn't find an official skill from the Astro team.
• Official adjacent options: Clerk's clerk-astro-patterns, and Vercel's vercel-optimize, which lists limited Astro support.

Astro keeps coming up in my own cost work because it ships so little JavaScript. That's part of how we keep ihatereading.in under $100 a month.

3. Animation and motion skills

Agents are bad at animation in a specific way: they add motion everywhere, use the wrong easing, animate layout properties that drop frames, and never think about interruption. The skills here fix the decision-making, not just the syntax.

emilkowalski/skills (community, by Emil Kowalski, who teaches animations.dev and built Sonner and Vaul)

This is the best-written skill repo in this post. Install it with npx skills@latest add emilkowalski/skills.

• animate: builds an animation from scratch by making decisions in order: should it animate at all, what for, which tool, which properties, which curve and duration, and how it handles interruption.
• review-animations: reviews motion code against a high craft bar. In its own words, "approval is earned."
• improve-animations: read-only audit of a codebase's motion code that produces a prioritized plan other agents can execute.
• find-animation-opportunities: finds places that should animate and rejects the ones that shouldn't, with exact values.
• animation-performance: keeps animations inside the frame budget by sticking to composite-only properties and keeping motion off a busy main thread.
• animation-vocabulary: turns "the bouncy thing when a popover opens" into the actual term, so you and the agent are talking about the same effect.
• apple-design: Apple's approach to fluid, physical, gesture-driven motion translated for the web.
• animate-expo: the same decision process for React Native and Expo.
• Also useful outside animation: break-ui (feeds your UI worst-case data like long names, emoji and zero items), pick-ui-library (an opinionated list for charts, OTP inputs, command menus and more), ask-sonner and emil-design-eng.

Framer Motion / Motion: I didn't find an official skill from the Motion team. Emil's animate and review-animations cover the decisions you make with Motion, and they work whichever library you pick.

Other motion skills worth knowing:

• react-view-transitions (official, Vercel): native-feeling page and element transitions with React's View Transition API, without a library.
• expo-animation (official, Expo): animation decisions for React Native, including which thread an animation runs on and spring vs timing.
• remotion-dev/skills (official, Remotion): for video made in React code. remotion-best-practices routes to the rest, including remotion-create, remotion-render, captions and maps. If you've ever tried to turn a blog into an explainer video, this is the stack for it. I wrote about that format in understanding LLM output faster.

4. Testing frontend apps

The most useful thing a skill can do is give the agent a browser and tell it to check its own work. "It compiles" and "it works" are different claims, and these skills close that gap.

• webapp-testing (official, Anthropic): a toolkit for testing local web apps with Playwright. It verifies frontend behavior, debugs UI, captures screenshots and reads browser logs. Use it after any UI change you'd otherwise check by hand.
• playwright-cli (official, Microsoft): browser automation and Playwright test work through Microsoft's Playwright CLI.
• next-dev-loop (official, Next.js): the runtime check for Next.js apps, described above.
• vitest (community, Anthony Fu): unit tests, mocking and coverage.
• clerk-testing (official, Clerk): end-to-end tests for auth flows with Playwright or Cypress, which is the part of an app most people skip testing.
• e2e-testing-patterns (community, wshobson/agents): general Playwright and Cypress patterns for reliable suites.
• break-ui (community): not a test runner, but it finds the layout bugs real users will hit first.

Use this category when: you've let an agent make UI changes across several files and you don't want to click through every screen yourself.

5. Authentication: Clerk, Better Auth, Firebase Auth, Neon Auth

Auth is where outdated training data hurts most, because SDKs change their APIs and the old ones still look plausible.

clerk/skills (official, Clerk)

Clerk has the most complete auth skill set I found, one skill per framework. Install the skills with npx skills add clerk/skills, or the plugin (skills plus the Clerk MCP server) with /plugin marketplace add clerk/skills and /plugin install clerk@clerk-skills.

There are also skills for Nuxt, Vue, React Router, Chrome extensions, Android and Swift in the same folder.

better-auth/skills (official, Better Auth)

• best-practices: server and client config, database adapters, sessions, plugins and environment variables.
• create-auth: scaffolds auth into a TypeScript app, detecting the framework and adding route handlers, OAuth providers and UI pages.
• Plus focused skills for emailAndPassword, organization, twoFactor and a security skill.

Firebase and Neon

• firebase-auth-basics (official, Firebase): sign-in, user management and auth-aware security rules.
• neon-auth (official, Neon): Neon Auth, which its skill describes as managed Better Auth, covering sign-up, magic links, OTP, OAuth, passkeys and organizations.

6. Payments and billing: Stripe, Dodo Payments, Polar

All three payment providers I use have official skills, which says a lot about where integration work is heading. I'd treat these as mandatory before letting an agent touch money.

stripe/ai (official, Stripe)

Install with claude plugin install stripe@claude-plugins-official, or npx skills add https://docs.stripe.com.

• stripe-best-practices: the one to always have. It guides integration decisions: test environments (separate sandboxes or the shared test mode), Checkout Sessions vs PaymentIntents, Connect setup and more.
• stripe-docs: reads and searches Stripe docs and API reference, including gated docs. Its description tells the agent to prefer it over curl or web fetches.
• upgrade-stripe: upgrading API versions, webhook endpoints, server SDKs, Stripe.js and mobile SDKs.
• connect-recommend and connect-required-verification-information: for marketplaces and platforms on Connect.
• metronome: usage-based billing with Metronome (event ingestion, rate cards, invoicing).
• stripe-apps, stripe-projects, stripe-directory and stripe-pay: Dashboard extensions, provisioning services through Stripe Projects, and agent-side payments.

dodopayments/skills (official, Dodo Payments)

Dodo Payments works as a merchant of record, so it acts as the seller and handles the tax side for you. Its agent skills page lists 18 skills, installed with npx skills add dodopayments/skills:

• Start here: dodo-best-practices (SDK setup, keys, the checkout-to-webhook architecture) and framework-adapters (official route handlers for Next.js, Express, Hono and others).
• Core flows: checkout-integration, subscription-integration (trials, plan changes, proration) and webhook-integration (Standard Webhooks verification).
• Billing models: usage-based-billing, credit-based-billing and license-keys. The credits one is the pattern most AI SaaS apps need.
• Going live: testing-and-go-live and refunds-and-disputes.
• Extras: mobile-checkout for React Native and Flutter, localized-pricing for purchasing power parity, billing-sdk for pricing table components and better-auth-integration.

polarsource/skills (official, Polar)

Four focused skills:

• setup-polar: an interactive onboarding wizard for adding Polar from scratch.
• polar-integration: Checkout, Customer Portal and Webhooks endpoints with @polar-sh/sdk, for any framework.
• polar-testing: testing in Polar's sandbox, including checkout flows without real payments and Stripe test cards.
• polar-migration: moving from Stripe Billing, Paddle, Lemon Squeezy or Gumroad.

Use this category when: you're adding checkout, changing plans, or upgrading an SDK. And always run the provider's testing skill before you flip to live keys.

7. Databases, BaaS and PostgreSQL

Supabase

supabase/agent-skills (official, Supabase) has only two skills, and both are broad:

• supabase: for any Supabase task, covering Database, Auth, Edge Functions, Realtime, Storage, Vectors, Cron and Queues, plus supabase-js and @supabase/ssr in Next.js and other frameworks.
• supabase-postgres-best-practices: Postgres best practices for Postgres running anywhere, not just on Supabase. It's meant to load before Claude creates or alters tables and columns. This is the best general Postgres skill I've found.

Install both with npx skills add supabase/agent-skills, or as plugins with claude plugin marketplace add supabase/agent-skills.

Firebase

firebase/agent-skills (official, Firebase). ihatereading.in runs on Firebase, so these are the ones I lean on:

• firebase-basics: CLI install, login, project setup and app config.
• firebase-firestore: Firestore data modeling, queries, indexes and SDKs.
• firestore-rules-creation and firebase-security-rules-auditor: writing production security rules, then auditing them for privilege escalation, role bypasses and create-vs-update gaps. Run the auditor on any project an agent has touched.
• firebase-data-connect-basics: Firebase's PostgreSQL-backed Data Connect.
• firebase-ai-logic-basics: calling Gemini models from client code.
• Also firebase-hosting-basics, firebase-app-hosting-basics, firebase-remote-config-basics, firebase-crashlytics and extension-to-functions-codebase.

My own SaaS starter kit is built on Firebase, and these skills cover the setup work it involves: CLI, Firestore, rules and hosting.

Neon and Prisma

• neondatabase/agent-skills (official, Neon): neon-postgres (pooled vs direct connections, migrations, autoscaling, scale-to-zero), neon-postgres-branches (testing migrations on a copy of real data) and neon-postgres-egress-optimizer, which hunts down code that pulls too much data out of the database and inflates your bill.
• prisma/skills (official, Prisma): prisma-orm-setup, prisma-client-api, prisma-cli, prisma-postgres and prisma-upgrade-v7.

PostgreSQL in depth

Beyond the vendor skills, three community skills go deeper into raw Postgres:

• postgresql-table-design (wshobson/agents): schema design, data types, indexing, constraints and Postgres-specific features.
• sql-optimization-patterns (wshobson/agents): query optimization, indexing strategy and reading EXPLAIN output.
• postgres-pro (Jeffallan/claude-skills): EXPLAIN analysis, JSONB, extensions, replication and VACUUM tuning.

My Postgres combination: supabase-postgres-best-practices always on, postgresql-table-design when designing a new schema, and sql-optimization-patterns when something is slow.

8. Mobile: Expo and React Native

Mobile has the richest official skill set of any category, because Expo went all in. If you build with React Native, this section is the reason to read this post.

Expo

expo/skills (official, Expo). Install with npx skills@latest add expo/skills --skill '*', or as a plugin with claude plugin install expo@claude-plugins-official.

Start with expo-overview. It's the entry point and router for every Expo and EAS task, and it's meant to load before Claude picks any other Expo skill.

Building the app

• expo-project-structure: folder layout for a new Expo Router app. It's for new projects only.
• expo-router: file-based routes, groups, dynamic routes, modals, form sheets, link previews and NativeTabs.
• expo-native-ui: native-feeling screens with Apple HIG styling, semantic colors, SF Symbols and native controls.
• expo-ui: the @expo/ui package, which renders real SwiftUI on iOS and Jetpack Compose on Android, for sheets, pickers, sliders, toggles and menus.
• expo-design-system: design tokens and a reusable component structure inside an Expo app.
• expo-data-fetching: any network request, with React Query, SWR, caching, offline support and loading, empty and error states.
• expo-animation: covered in the animation section.
• expo-examples: points the agent at Expo's roughly 70 official with-* example projects (Stripe, Clerk, Supabase, OpenAI, maps, SQLite, Skia, NativeWind and more), so it copies a working integration instead of inventing one.

Going native and migrating

• expo-module: writing native modules and views with the Expo Modules API in Swift and Kotlin.
• expo-dom and expo-web-to-native: running web code inside native screens, and porting a whole Next.js, Vite or CRA app to iOS and Android.
• expo-brownfield: embedding React Native screens in an existing native app.
• expo-upgrade: SDK upgrades and dependency fixes.

Shipping with EAS

• eas-app-stores: build and submit to TestFlight, the App Store and Google Play.
• eas-update and eas-update-insights: over-the-air updates, then crash rates and adoption per update.
• eas-workflows: CI/CD YAML in .eas/workflows/.
• eas-hosting: deploying Expo web builds and API routes.
• Plus expo-dev-client, eas-observe, eas-simulator (cloud simulators, marked experimental) and expo-app-clip.

React Native

• callstackincubator/agent-skills (from Callstack, the React Native consultancy): react-native-best-practices covers FPS, time to interactive, bundle size, memory leaks, re-renders and Hermes. upgrading-react-native applies template diffs and handles CocoaPods and Gradle changes, which is the most painful job in React Native. There's also react-navigation, create-react-native-library, github-actions for simulator and emulator CI builds, and brownfield migration skills.
• react-native-skills (official, Vercel): React Native and Expo performance, covering list performance, animations and native modules.
• Related skills from other sections: clerk-expo for auth, Dodo's mobile-checkout for payments and Emil's animate-expo for motion.

9. AI, LLMs and deep learning

This category splits in two: skills for building apps on top of models, and skills for training models.

OpenRouter (building on many models)

OpenRouterTeam/skills (official, OpenRouter). I route most of my agents through OpenRouter, so this is the repo I check first:

• openrouter-typescript-sdk: the reference for calling 300+ models through the TypeScript SDK and the callModel pattern.
• openrouter-models and openrouter-benchmarks: query live model pricing, context lengths and capabilities, and benchmark rankings. Use these instead of letting the agent guess model IDs from memory.
• create-headless-agent and create-agent-tui: scaffold an agent in TypeScript with @openrouter/agent, either headless (CLIs, API servers, queue workers) or with a terminal UI.
• openrouter-analytics: answers questions about your own spend, model mix, latency and tokens.
• openrouter-oauth: "Sign In with OpenRouter" with OAuth PKCE, so users bring their own model credits.
• Media: openrouter-images, openrouter-video, openrouter-tts and openrouter-stt.

I used OpenRouter for the blog-to-carousel pipeline, and the images skill covers the same API.

Anthropic's own AI skills

• claude-api (official, Anthropic): reference for the Claude API and Anthropic SDK, covering model IDs, streaming, tool use, MCP, caching and token counting.
• mcp-builder (official, Anthropic): a guide to building good MCP servers that give models well-designed tools.
• skill-creator (official, Anthropic): creates and edits skills and runs evals on them. Use it to write your own skills for anything missing from this list.

Hugging Face (training, evals and local models)

huggingface/skills (official, Hugging Face). Hugging Face wrote up getting Claude to fine-tune an open-source LLM with these skills.

• huggingface-llm-trainer: trains or fine-tunes language and vision models with TRL or Unsloth on Hugging Face Jobs, covering SFT, DPO, GRPO and reward modeling.
• trl-training: writing and debugging post-training code with TRL directly.
• huggingface-vision-trainer: object detection and image classification fine-tuning.
• huggingface-community-evals: evals with inspect-ai and lighteval on local hardware.
• huggingface-local-models: picking GGUF models and quantizations for llama.cpp on CPU, Mac Metal, CUDA or ROCm.
• transformers-js: running models in JavaScript and the browser.
• huggingface-datasets, huggingface-gradio, huggingface-spaces, hf-cli and huggingface-best for choosing a model by benchmark.

LLM app patterns and fine-tuning theory (community)

wshobson/agents has two plugin folders worth installing whole:

• llm-application-dev: rag-implementation, embedding-strategies, hybrid-search-implementation, llm-evaluation and prompt-engineering-patterns.
• llm-finetuning: finetuning-method-selection starts by asking whether to fine-tune at all, then routes to SFT, DPO or GRPO. lora-qlora-recipes, dataset-curation and eval-harness-first cover the rest.

Jeffallan/claude-skills adds rag-architect and fine-tuning-expert.

If you want to understand what these skills are configuring under the hood, start with how large language models work, which walks through tokens, attention and transformers with code.

10. Servers and cloud functions: Hono, Express, Workers, Vercel

Hono

• honojs/skills (official, Hono): hono covers routing, middleware, validation, testing and streaming, and triggers whenever code imports from hono. hono-jsx covers server-rendered UI with hono/jsx, built with Vite.

Hono is my default for small APIs. I once put an entire web scraping API in one Hono file, and that's exactly the kind of project the hono skill is built for.

Express

There's no official Express skill. Two good options:

• nodejs-backend-patterns (community, wshobson/agents): production Node.js services with Express or Fastify, covering middleware, error handling, auth, database integration and API design.
• Dodo's framework-adapters (official): if all you need is payment routes in Express or Hono, it has official route handlers for both.

Cloudflare Workers

cloudflare/skills (official, Cloudflare):

• workers-best-practices and wrangler: writing Workers and running the Wrangler CLI.
• durable-objects and agents-sdk: stateful coordination and Cloudflare's Agents SDK.
• nextjs-on-cloudflare: running Next.js on Workers, including choosing between vinext and OpenNext.
• web-perf: Core Web Vitals and Lighthouse audits. It works on any site, not just Cloudflare ones.

Serverless functions on your BaaS

• Vercel: deploy-to-vercel and vercel-optimize.
• Supabase Edge Functions: covered by the main supabase skill.
• Firebase: firebase-app-hosting-basics for SSR apps, and extension-to-functions-codebase for converting Firebase Extensions into Cloud Functions code.
• Neon: neon-functions runs long-running Node.js HTTP functions on your Neon branch, with DATABASE_URL injected automatically.

11. Rust

There's no official skill from the Rust project, but the community work here is serious.

• actionbook/rust-skills (community): the most thorough Rust set I found. It's organized as numbered modules that trigger on actual compiler errors. m01-ownership fires on borrow-checker errors like E0382 and E0597, m06-error-handling covers Result, anyhow and thiserror, and m07-concurrency covers Send/Sync, channels, mutexes and Tokio. unsafe-checker reviews unsafe code and FFI, and rust-router sends each question to the right module.
• trailofbits/skills (from Trail of Bits, the security firm): rust-review is a security review covering unsafe boundaries, concurrency hazards, panics that can cause denial of service, and FFI safety. The same repo has cargo-fuzz for fuzzing.
• wshobson/agents (community): rust-async-patterns for Tokio and async traits, and memory-safety-patterns for RAII, ownership and smart pointers.
• rust-engineer (community, Jeffallan/claude-skills): a general-purpose skill for idiomatic Rust, lifetimes, traits and async with Tokio.

My suggestion: install rust-router plus the numbered modules if you're learning, and add rust-review before anything with unsafe goes to production.

12. System design and API design

These skills don't write features. They make the agent think before it writes them, which is where most expensive mistakes happen.

API design

• api-design-principles (community, wshobson/agents): REST and GraphQL design for new APIs and spec reviews.
• api-designer (community, Jeffallan/claude-skills): resource modeling, versioning, pagination and error-handling standards, plus OpenAPI specs.
• openapi-spec-generation (community, wshobson/agents): OpenAPI 3.1 specs from code or design-first, for docs and SDK generation.

System design and architecture

• architecture-designer (community, Jeffallan/claude-skills): high-level architecture, diagrams and Architecture Decision Records.
• architecture-patterns (community, wshobson/agents): Clean Architecture, Hexagonal Architecture and Domain-Driven Design.
• microservices-patterns and microservices-architect: service boundaries, event-driven communication, resilience, and breaking up a monolith.
• cqrs-implementation and saga-orchestration: separate read and write models, and distributed transactions without two-phase commit.
• distributed-tracing: tracing requests across services with Jaeger and Tempo.

A fair warning: for a solo project, most of these will push you toward more architecture than you need. Use them to review a design, not to generate one. A monolith on one server gets you further than people think.

13. Docker and Kubernetes

Docker

docker/skills (official, Docker):

• docker-build-strategies: writing and optimizing Dockerfiles, including multi-stage builds, smaller images, faster builds and production hardening.
• docker-compose-patterns: wiring services together and adding a database to local dev.
• docker-project-foundations: Dockerizing a project from scratch.
• docker-destructive-guardrails: loads before any command that deletes or resets state. This is the one I'd insist on, because "clean up Docker" is how agents wipe volumes.
• Docker's agent tooling: docker-agent-config, docker-agent-run, docker-agent-deploy, and the docker-sandboxes-lifecycle family for running coding agents in isolated microVMs.

Sandboxes for agents are a whole topic of their own. I covered the wider space in AI agent sandbox SDKs and APIs.

Kubernetes

No official Kubernetes skill exists that I could find, and Kubernetes is where model hallucinations are most dangerous: deprecated API versions, missing resource limits, privileged pods.

• LukasNiessen/kubernetes-skill (community): a single SKILL.md built to stop exactly those mistakes: insecure workload defaults, resource starvation, network exposure, privilege sprawl, fragile rollouts and API drift.
• kubernetes-operations (community, wshobson/agents): k8s-manifest-generator, k8s-security-policies (NetworkPolicy and RBAC), helm-chart-scaffolding and gitops-workflow with Argo CD and Flux.
• kubernetes-specialist and devops-engineer (community, Jeffallan/claude-skills): manifests, pod debugging, CI/CD and Terraform.

14. Email, SMS and WhatsApp

Every SaaS sends email eventually: a magic link, a receipt, a weekly digest. Agents can write the send call easily. What they get wrong is deliverability, which is why these skills spend so much time on DNS records and spam rules.

resend/resend-skills (official, Resend). Install with npx skills add resend/resend-skills.

• resend: the Resend email API, covering transactional sends (single and batch), inbound email through webhooks, templates, delivery events and domains.
• react-email: building HTML email templates with React components, rendering them to HTML, and adding React Email's visual editor to your own app.
• email-best-practices: the deliverability skill, covering emails landing in spam, bounce rates, SPF, DKIM and DMARC setup, and compliance with CAN-SPAM, GDPR and CASL. Run it before your first real send.
• agent-email-inbox: for systems where incoming email triggers actions, such as AI support inboxes or email-to-task pipelines. Its description treats inbound email as untrusted input, which is the right default for anything an agent reads.
• resend-cli: running Resend from the terminal (sends, domains, broadcasts, webhooks, logs).

twilio/skills (official, Twilio)

Twilio's repo is huge, with around 50 skills across Twilio and SendGrid. The ones most indie products need:

• twilio-messaging-overview: start here. It compares SMS, WhatsApp, RCS and Messenger, and covers the unified Messages API.
• twilio-verify-send-otp: one-time passcodes over SMS, voice, email or WhatsApp with Twilio Verify. This is the right way to do phone login, instead of building OTP storage yourself.
• twilio-whatsapp-send-message: WhatsApp's 24-hour service window, template approval and sandbox testing. WhatsApp is how a lot of Indian businesses actually talk to customers, so this one matters if you build for them.
• twilio-sms-send-message: SMS and MMS error codes, and a checklist for messages being filtered or blocked.
• twilio-webhook-architecture: inbound events, status callbacks and signature validation.
• twilio-sendgrid-email-send: transactional and bulk email through SendGrid, if you're on SendGrid instead of Resend.

15. Voice AI and audio

Voice agents are one of the fastest-moving areas right now, which makes official skills more valuable than usual. Model names, latency settings and pricing change month to month. I compared the main platforms in AI voice agents for SMB receptionists, and looked at a real use case in voice-first recruiting.

elevenlabs/skills (official, ElevenLabs). Install with npx skills add elevenlabs/skills.

• agents: building voice AI agents, such as voice assistants, customer service bots and interactive characters.
• speech-engine: adding real-time voice conversations to your own agent runtime, with WebSocket and WebRTC clients.
• text-to-speech and speech-to-text: voiceovers in 90+ languages, and transcription and subtitles with Scribe v2.
• dubbing: translating audio and video while keeping the original speakers' voices.
• music, sound-effects, voice-changer and voice-isolator: generated music and sound, voice conversion and noise removal.

livekit/agent-skills (official, LiveKit)

LiveKit's set is the most complete lifecycle for voice agents I found, from build to production:

• building-livekit-agents: voice and chat agents with LiveKit Agents and LiveKit Cloud.
• reading-livekit-docs: looks up current API signatures, CLI flags and model support instead of answering from memory.
• testing-livekit-agents: turn-level tests in pytest or Vitest.
• writing-livekit-scenarios and running-livekit-simulations: simulated conversations to regression-test an agent before deploying.
• debugging-livekit-agents and operating-livekit-agents: live debugging with lk agent debugger, then deploys, rollbacks and secrets in production.

Also in this space: Twilio's twilio-voice-conversation-relay for AI voice agents over phone calls, and OpenRouter's openrouter-tts and openrouter-stt if you'd rather keep one AI provider.

16. Web scraping and browser automation

Scraping is half of what I build: lead lists, trend trackers, the research agents behind this blog. I've written about how the scraping APIs compare and about the agent dashboard we run our scrapers from. These skills are the agent-side version of that work.

firecrawl/skills (official, Firecrawl). Install with npx skills add firecrawl/skills.

The repo is split three ways, which is a nice pattern for any skill repo:

• Core (do it now): firecrawl handles any live-web task through the Firecrawl CLI. The focused ones are firecrawl-search, firecrawl-scrape, firecrawl-map (list a site's URLs), firecrawl-crawl (everything under /docs) and firecrawl-agent, which navigates sites on its own to extract structured data.
• Build (put it in your product): firecrawl-build, firecrawl-build-scrape and firecrawl-build-search integrate Firecrawl into your app's code rather than running it once.
• Workflows (finished jobs): firecrawl-lead-gen, firecrawl-lead-research, firecrawl-deep-research, firecrawl-market-research, firecrawl-seo-audit and firecrawl-website-design-clone, which extracts any site's colors, fonts and spacing into a DESIGN.md.

browserbase/skills (official, Browserbase). Install with npx skills add browserbase/skills.

• browser and fetch: drive a browser with natural language through a CLI, or grab a URL without a full browser session.
• functions: deploy browser automation as serverless cloud functions on a schedule or webhook.
• browser-to-api: turns a site's network traffic into a best-effort OpenAPI spec, which is often better than scraping HTML.
• ui-test: adversarial UI testing that reads your git diff and tests only what changed.
• add-webmcp: adds WebMCP tools to your own web app so agents can use it properly. If WebMCP is new to you, start with the sweet shop explainer.
• safe-browser and autobrowse: a browser agent restricted to an allowlist of domains, and a loop that improves a browsing strategy until a task reliably passes.

vercel-labs/agent-browser (official, Vercel Labs)

• agent-browser: a browser automation CLI built for agents, covering navigation, forms, clicks, screenshots and extraction.
• dogfood: exploratory QA. It explores your app hunting for bugs and UX issues, which pairs well with the testing skills in section 4.

17. Analytics, feature flags and error tracking

PostHog/skills (official, PostHog)

PostHog has the largest single skill repo in this post: 339 SKILL.md files when I counted, though some are packaged copies of the same skill. Most of them drive PostHog through its MCP server to analyze data, but the ones that matter most while you build are the instrumentation skills. Install with /plugin marketplace add PostHog/skills, then pick plugins such as posthog-integration or posthog-feature-flags.

• instrument-product-analytics: adds analytics events for meaningful user actions. It's meant to run after you build a feature or review a PR.
• instrument-error-tracking: exception capture with stack traces.
• instrument-feature-flags: wraps new functionality in flags for safe rollouts.
• instrument-llm-analytics: traces every LLM generation with token counts. Pair it with exploring-llm-costs to see spend by model, user or feature.
• creating-experiments and creating-surveys: A/B tests, and NPS or feedback surveys.
• investigating-error-issue and cleaning-up-stale-feature-flags: debugging one error end to end, and removing old flags and the code that checks them.

The habit worth stealing: these instrumentation skills describe themselves as things to run after a feature is built. Put "run instrument-product-analytics and instrument-error-tracking" at the end of your feature checklist and every feature ships with tracking already in place.

18. More databases, caching and queues

Section 7 covered Postgres and the big BaaS platforms. Every one of these also has an official skill repo:

Convex: get-convex/agent-skills (official). Over 30 skills. Start with convex and convex-quickstart. Before launch, run convex-reviewer for security, auth and validator checks, and convex-launch-readiness, which its description calls "Lighthouse for your backend." There are also skills for convex-auth, convex-crons, convex-migrate and convex-test.

MongoDB: mongodb/agent-skills (official). mongodb-schema-design covers patterns and anti-patterns, including migrating from SQL. mongodb-query-optimizer handles indexing and slow queries, mongodb-connection handles pools and timeouts, and mongodb-search-and-ai covers Atlas full-text, vector and hybrid search.

Redis: redis/agent-skills (official). redis-core picks the right data structure and key naming. redis-connections covers pooling, pipelining and avoiding slow commands like KEYS. redis-semantic-cache caches LLM responses by meaning, which cuts repeat LLM calls for similar questions. redis-search and redis-security round it out.

Upstash: upstash/skills (official). This is the serverless toolbox: upstash-redis-js for HTTP-based Redis on the edge, upstash-ratelimit-js for rate limiting an API route (do this before you launch anything with an AI endpoint), upstash-qstash-js for queues and scheduled jobs, upstash-workflow-js for long-running workflows that survive serverless timeouts, and upstash-vector-js for embeddings and RAG.

Turso (SQLite): tursodatabase/agent-skills (official). turso-db for the in-process database written in Rust (formerly libSQL), and turso-cloud for the managed version.

PlanetScale: planetscale/skills (official). These are built around letting agents operate databases safely: planetscale-postgres-safety-review, planetscale-pscale-cli-automation, planetscale-query-insights-and-tags, and planetscale-schema-recommendations-agent-loop, which turns schema recommendations into reviewed branches and pull requests without touching production.

19. Vue, Nuxt and Svelte

Not everything is React. The two non-React frameworks with the best skill coverage:

• Svelte: sveltejs/ai-tools (official, Svelte team). svelte-core-bestpractices covers modern Svelte 5 code, including reactivity. svelte-code-writer gives the agent CLI tools to look up Svelte 5 docs and analyze components, and its description says to use it for any .svelte file. Svelte 5 introduced runes, so older training data is a real risk here.
• Vue and Nuxt: antfu/skills (community, Anthony Fu). vue covers the Composition API, <script setup> macros and reactivity, nuxt covers SSR, server routes and useFetch, and pinia covers stores. Clerk also has official clerk-vue-patterns and clerk-nuxt-patterns.
• pnpm, whatever framework you use: pnpm covers workspaces, catalogs, patches and overrides.

20. Python, FastAPI and Go

A lot of AI backend work is still Python. I covered the agent frameworks themselves in Python AI SDKs compared. These skills cover the language and tooling around them:

• modern-python (Trail of Bits): sets up projects with uv, ruff and ty, and migrates old pip or Poetry setups. If you install one Python skill, make it this one.
• wshobson/agents python-development (community): 16 focused skills, including async-python-patterns, python-testing-patterns (pytest, fixtures, mocking), uv-package-manager and python-project-structure.
• fastapi-expert (community, Jeffallan/claude-skills): async APIs with FastAPI and Pydantic v2. The same repo has python-pro for type-safe Python 3.11+.
• Go: golang-pro (community) covers goroutines, gRPC or REST microservices and profiling with pprof, and wshobson's go-concurrency-patterns goes deeper on channels, sync primitives and context.

21. Security and code review

Agents write code fast, so they write vulnerabilities fast too. These skills are the second pair of eyes. If you're thinking about audits more formally, AI agent auditing and compliance covers that side.

getsentry/skills (official, Sentry's engineering team). These are Sentry's internal engineering skills, not Sentry SDK setup. Install with claude plugin marketplace add getsentry/skills, then claude plugin install sentry-skills@sentry-skills.

• find-bugs: bugs, security issues and quality problems in your current branch's changes. It makes a good "before I push" check.
• security-review: an OWASP-style review for injection, auth problems and similar.
• code-review and code-simplifier: PR reviews following Sentry's practices, and cleanup that keeps behavior the same.
• gha-security-review: GitHub Actions workflows reviewed for exploitable patterns.
• skill-scanner: scans agent skills for security problems such as prompt injection. Run it on every community skill in this post before you install it. That's the safety advice from the start of this post, automated.

trailofbits/skills (from Trail of Bits, the security firm):

• differential-review: security-focused review of a set of code changes.
• semgrep and codeql: static analysis scans. The Semgrep skill presents its scan plan for your approval before running.
• supply-chain-risk-auditor: checks your dependencies for advisories and supply-chain risk.
• sharp-edges: finds error-prone APIs and dangerous configurations that make security mistakes easy.

Also: Better Auth's security skill (rate limiting, CSRF, trusted origins, session cookies), Firebase's firebase-security-rules-auditor from section 7, and Jeffallan's security-reviewer and secure-code-guardian (community).

22. Git, CI/CD and infrastructure as code

Git and pull requests, from getsentry/skills (official):

• commit: conventional commits with issue references.
• pr-writer: PR titles and descriptions written for the reviewer.
• iterate-pr: loops on a PR until CI passes and high and medium review feedback is handled. This is the closest thing to "fix it until it's green" that I've found packaged as a skill.

CI/CD pipelines:

• github-actions-templates, deployment-pipeline-design and secrets-management (community, wshobson/agents): workflows for testing, building and deploying, multi-stage pipelines with approval gates, and secrets handling with Vault or AWS Secrets Manager.
• Platform-specific: Callstack's github-actions for React Native builds, and Expo's eas-workflows.

Infrastructure as code: hashicorp/agent-skills (official, HashiCorp). Install single skills by path, for example npx skills add hashicorp/agent-skills/plugins/terraform/skills/terraform-style-guide.

• terraform-style-guide: HCL that follows HashiCorp's official conventions.
• terraform-test: .tftest.hcl tests with run blocks.
• refactor-module: splits a monolithic config into reusable modules.
• terraform-search-import: finds existing cloud resources and bulk-imports them into Terraform. This is how you rescue infrastructure someone clicked together in a console.
• terraform-stacks, plus Packer skills like aws-ami-builder for machine images.

23. Marketing, SEO and growth

Building is the easy part. These skills cover what comes after, and they're the ones I'd point most indie hackers to first, since distribution is usually the actual bottleneck.

coreyhaines31/marketingskills (community, by Corey Haines). Around 50 marketing skills. Install with npx skills add coreyhaines31/marketingskills, or pick a few with --skill.

• SEO: seo-audit, programmatic-seo (template pages at scale), schema (JSON-LD) and ai-seo, for getting cited in AI answers. That last one is the same problem I covered in the AEO guide and AI visibility checkers.
• Launch and distribution: launch (Product Hunt and go-to-market), directory-submissions (pair it with our list of 393 SaaS directories), cold-email and lead-magnets.
• Conversion and pricing: copywriting, cro, pricing, paywalls and onboarding.
• Mobile: aso for App Store and Google Play listings.

Firecrawl's firecrawl-seo-audit from section 16 is a good companion, because it crawls the live site rather than reasoning from your code. And if you're producing content at volume, read how we write 100+ SEO blogs a day before you point an agent at a keyword list.

24. Documents and office files

Sometimes the output isn't code: an invoice PDF, a client report in Word, a pitch deck, a spreadsheet of leads. Anthropic's anthropics/skills repo publishes the source for its document skills:

• pdf: read, extract, merge, split, fill forms and watermark PDFs.
• docx: create and edit Word documents and templates.
• pptx: create, read and edit PowerPoint decks.
• xlsx: spreadsheets in .xlsx, .csv and .tsv.
• doc-coauthoring: a structured workflow for writing specs, proposals and decision docs together with Claude.

Anthropic's docs note that the pre-built document skills aren't part of Claude Code itself, so installing them from this repo is how you get them there. Check the license in each skill folder before using them in a commercial product.

The 20 skills I'd install first

If this list is too much, start here. One per job, mostly official.

The next five, from the later sections: find-bugs before every push, skill-scanner before installing any community skill, email-best-practices before your first real email, instrument-product-analytics after every feature, and upstash-ratelimit-js before any AI endpoint goes public.

How to use skills without making things worse

• Install per project, not globally. Every installed skill puts its description in context, at around 100 tokens each. Fifty skills you don't need is 5,000 tokens of noise and more chances for the wrong skill to fire. Put framework skills in the project's .claude/skills/ and keep only general ones (design, testing) in ~/.claude/skills/.
• Prefer official when both exist. They track releases. Community skills are great for gaps (Rust, Kubernetes, system design), but check when they were last updated.
• Read before you install. Skills can run scripts. Open the SKILL.md and the scripts/ folder of anything community-made.
• Update them. Manually installed skills don't auto-update. npx skills update refreshes them, and plugin installs update through Claude Code.
• Pair skills with MCP when the vendor offers both. Skills teach the agent how; MCP servers let it act. Clerk, Expo, Stripe and Hugging Face all ship both, and the Expo README explains the split well.
• Write your own for your stack. The prompts collection for Cursor, Codex and Claude Code is a good source of rules to turn into skills with skill-creator.

Where to go from here

Pick the three categories you work in most, install the official skills for them, and run your next feature through webapp-testing or next-dev-loop before you call it done. That's the shortest path from "the agent wrote it" to "the agent proved it works."

For the bigger lists, VoltAgent/awesome-agent-skills collects skills from official dev teams and the community, and wshobson/agents and Jeffallan/claude-skills cover almost every language.

Everything we've open-sourced ourselves is in the iHateReading open-source projects post. New tools and skill repos go into the monthly magazine as they land.