A complete breakdown of the skills that matter, organized by what they actually do. No generic lists. Real names, real descriptions, real use cases.
A Claude Code skill is a markdown instruction file — typically named SKILL.md — that loads into Claude's context when a task matches its domain. Skills are not prompts. They are structured instruction sets with trigger conditions, step-by-step procedures, quality standards, and anti-patterns to avoid.
When you tell Claude to "build a dashboard with Supabase and shadcn," a pre-task hook classifies that request and injects the relevant skills —supabase/SKILL.md, shadcn-ui/SKILL.md, and react-best-practices/SKILL.md — before Claude writes a single line of code. The result is output that follows documented best practices for each technology, not whatever patterns happened to be in the training data.
Skills live at ~/.claude/skills/ (global) or .claude/skills/ (project-level). They are plain text files you can read, edit, and version control. No compiled binaries. No vendor lock-in. No black box behavior.
The ecosystem now has over 1,700 skills. We reviewed 152 of the most impactful ones for this ranking. The criteria: measurable improvement in output quality, active maintenance, clear documentation, and real-world usage by development teams shipping production software.
Without skills, Claude operates from its training data. That training data is broad but shallow — it knows React exists, but it does not know your team's component conventions. It can write SQL, but it will not enforce your Row Level Security patterns. It generates TypeScript, but with any types scattered through the output when the type system gets complicated.
Skills fix this by injecting domain-specific standards at the moment of execution. The difference between "write a Next.js page" and "write a Next.js page with the react-best-practices skill loaded" is the difference between a junior developer guessing and a senior developer following documented patterns. Same model. Different instructions. Dramatically different output.
What changes when skills are loaded:
The compounding effect is significant. A team running 40+ Claude sessions per week with skills loaded saves hours of correction cycles. Over a month, that compounds into shipping features faster with fewer regressions. Skills are not a nice-to-have. They are the mechanism that turns Claude from a capable model into a reliable engineering partner.
Ranked by impact on output quality, breadth of coverage, community adoption, and how often they trigger across real development workflows. These are the skills that the largest number of teams keep installed permanently.
The highest-starred skill in the entire ecosystem. Superpowers bundles a complete development methodology — architecture planning, implementation patterns, code review standards, and deployment checklists — into a single SKILL.md that loads automatically on coding tasks. It rewires how Claude approaches multi-file changes, enforcing incremental verification and rollback-safe edits. If you install one skill, this is the one.
A collection of 23 specialist development tools packaged as a single skill. GStack covers linting, formatting, testing, bundling, CI/CD configuration, and dependency management. It replaces the need for a dozen separate skill files by consolidating the most common development operations into one coherent instruction set. Particularly strong on monorepo workflows and build optimization.
Overrides the default visual biases that plague LLM-generated interfaces. Taste-skill enforces metric-based spacing rules, strict component architecture, CSS hardware acceleration, and balanced design engineering. It prevents the generic look that makes AI-built UIs immediately recognizable — no excessive gradients, no card-soup layouts, no decorative borders everywhere. The skill that makes Claude build interfaces that look like a senior designer shipped them.
GEO-first SEO methodology built specifically for AI-assisted content workflows. Handles keyword research, content briefs, on-page optimization, internal linking strategy, schema markup, and SERP analysis. It is not a generic "write SEO content" prompt — it is a structured process that produces articles ranking in competitive niches. Includes anti-AI-slop rules that strip out the filler phrases search engines penalize.
Domain-specific skill for financial software development. Covers regulatory compliance patterns, transaction safety, audit logging, precision arithmetic (no floating point for currency), and PCI-DSS compatible data handling. If you are building fintech, banking integrations, or payment processing, this skill prevents the category of bugs that result in compliance violations or incorrect monetary calculations.
Performance optimization guidelines sourced from Vercel Engineering. Covers component composition, render optimization, lazy loading, bundle splitting, server component patterns, and data fetching strategies. Triggers automatically on any React or Next.js task. The skill reduces re-renders, eliminates common performance pitfalls, and enforces patterns that scale from prototype to production without refactoring.
Comprehensive Supabase skill covering database schema design, Row Level Security policies, Edge Functions, Realtime subscriptions, Auth configuration, and Storage management. Triggers on any task involving Supabase products or client libraries. Handles the full SSR integration path for Next.js, SvelteKit, and Astro, including cookie-based auth flows that most developers get wrong the first three times.
Node.js development principles focused on decision-making rather than code copying. Covers framework selection criteria, async pattern tradeoffs, security hardening, error handling architecture, and process management. Teaches Claude to think about backend design decisions instead of blindly applying Express boilerplate. Strong on middleware patterns and graceful shutdown handling.
Expert guidance for shadcn/ui integration — component discovery, installation, customization, theming, and composition patterns. Handles the full workflow from adding components to building complex compound interfaces. Knows which components pair well, how to extend primitives without breaking updates, and how to maintain design consistency across a project using the component registry.
Multi-agent swarm orchestration for parallel task execution. Handles agent spawning, topology selection (hierarchical, mesh, pipeline), consensus coordination, and result aggregation. This is the skill that enables Claude to decompose a large task into subtasks, assign them to specialist agents, and merge the results. Required for any workflow that benefits from parallel execution across non-overlapping files.
Beyond the top 10, the full ranked list spans seven categories. Each skill listed here is actively maintained and included in the AI Brain Pro package. Browse the full skills directory for the complete searchable catalog.
react-best-practicesVercel Engineering patterns for React/Next.js performancetaste-skillAnti-slop UI engineering with metric-based spacing rulesshadcn-uiComponent discovery, installation, and compositiontailwind-css-patternsUtility-first styling, responsive design, layout systemstailwind-v4-shadcnProduction-tested Tailwind v4 + shadcn setup with dark modecomposition-patternsCompound components, render props, scalable React APIsnext-best-practicesNext.js App Router conventions, caching, and renderingfrontend-designDistinctive, production-grade interfaces that avoid AI aestheticssoft-skillHigh-end agency design — fonts, shadows, card structures, animationsaccessibilityWCAG 2.2 compliance, screen readers, keyboard navigationsupabaseFull Supabase stack — RLS, Edge Functions, Auth, Realtime, Storagesupabase-postgres-best-practicesQuery optimization, indexing, schema designnodejs-best-practicesFramework selection, async patterns, security, architecturenodejs-backend-patternsExpress/Fastify middleware, error handling, API designtypescript-advanced-typesGenerics, conditional types, mapped types, utility typesfinancial-servicesCompliance patterns, precision arithmetic, audit loggingclaude-seoGEO-first SEO methodology with anti-AI-slop ruleswrite-contentFull SERP-researched article writing with banned phrase listscontent-briefKeyword research, competitor analysis, writer-ready briefskeyword-deep-diveSERP analysis, intent classification, 90-day ranking planstopic-cluster-planningHub-and-spoke content architecture with internal linkingsemantic-gap-analysisEntity and subtopic gaps versus top-ranking competitorsfeatured-snippet-optimizerRewrite content sections to win featured snippetseeat-auditE-E-A-T signal scoring and improvement recommendationsimprove-contentRefresh underperforming pages with SERP-aware rewritesv3-security-overhaulCVE remediation, secure-by-default patternscode-reviewerAutomated code review with correctness and style checksverification-qualityTruth scoring with 0.95 accuracy threshold and auto-rollbackcodex-adversarialTwo-AI adversarial review — one writes, one attackssecurity-reviewVulnerability scanning, threat modeling, dependency auditpost-writerVoice-matched LinkedIn posts from about-me.md and voice.mdhook-generatorSix clickbait-style hook variations per topiccontent-matrix32+ post ideas from pillars x formats (Justin Welsh method)post-scorerScore drafts against your own past performance datagraphic-designerLinkedIn graphics — HTML/CSS structured or AI-generatedprofile-optimizerHeadline, about, experience, and featured section rewriteshumanizerStrip AI writing tells — filler words, passive voice, hedginggemini-infographicHand-drawn whiteboard infographic prompts for Geminimempalace-memoryHierarchical memory system with spatial organizationagentdb-memory-patternsPersistent session memory, long-term storage, context managementagentdb-vector-searchSemantic search with HNSW indexing for document retrievalagentdb-optimizationQuantization, caching, batch ops — scale to millions of vectorsagentdb-learningReinforcement learning with 9 algorithms including Decision Transformercass-memoryThree-layer cognitive architecture with confidence decayllm-wikiPersistent knowledge base pattern for long-running projectsclaude-os-memoryCore memory management for Claude operating system workflowsswarm-orchestrationMulti-agent swarms with dynamic topology and coordinationswarm-advancedResearch, development, testing, and distributed workflow patternssparc-methodologySpecification, Pseudocode, Architecture, Refinement, Completionauto-delegationAutonomous agent orchestration — every task gets delegatedhooks-automationPre/post hooks for formatting, learning, and coordinationpair-programmingDriver/navigator modes with TDD, debugging, and role switchinggithub-workflow-automationAI-coordinated CI/CD pipelines and repo managementv3-swarm-coordination15-agent hierarchical mesh for parallel domain executionThis list covers 64 of the 152 ranked skills. The remaining 88 span niche domains — Three.js rendering pipelines, video generation with Remotion, Dify platform integration, n8n automation workflows, and dozens of framework-specific optimization skills. The full catalog is searchable in the ecosystem directory.
Skills are markdown files. Installation is copying a file to the right directory. There is no package manager, no build step, no dependency resolution. That simplicity is intentional — skills should be auditable plain text, not compiled artifacts you cannot inspect.
Download a SKILL.md file and place it in your skills directory:
# Global skills (available in every project)
mkdir -p ~/.claude/skills/react-best-practices/
cp SKILL.md ~/.claude/skills/react-best-practices/SKILL.md
# Project-level skills (scoped to one project)
mkdir -p .claude/skills/custom-patterns/
cp SKILL.md .claude/skills/custom-patterns/SKILL.mdGlobal skills load across all projects. Project-level skills override globals when both exist for the same domain.
The AI Brain Pro package includes all 152 ranked skills pre-organized in the correct directory structure. Extract the archive and the skills are ready:
# Extract the Brain Pro archive
tar -xzf ai-brain-pro.tar.gz -C ~/.claude/
# Verify installation
ls ~/.claude/skills/ | wc -l
# Output: 152+ directoriesOnce installed, you can search your skill library from within Claude Code:
# Find skills matching a keyword
ls ~/.claude/skills/ | grep react
# react-best-practices/
# react-three-fiber/
# react-components/
# Read a specific skill
cat ~/.claude/skills/react-best-practices/SKILL.mdThe real power of skills is not having to think about which ones to load. A properly configured AI Brain uses pre-task hooks to classify every request and inject matching skills automatically. You ask Claude to do something. The system figures out which skills apply. Claude executes with those instructions loaded.
The auto-selection pipeline:
The mapping between task keywords and skills is configurable. The default 61 mappings cover common development workflows:
| Task keyword | Skills loaded |
|---|---|
| react, component, hook | react-best-practices, composition-patterns |
| supabase, database, rls | supabase, supabase-postgres-best-practices |
| seo, keyword, ranking | claude-seo, write-content, content-brief |
| security, auth, vulnerability | v3-security-overhaul, security-review |
| design, ui, layout, css | taste-skill, tailwind-css-patterns, soft-skill |
| deploy, ci, pipeline | github-workflow-automation, deploy-to-vercel |
| swarm, agent, orchestrate | swarm-orchestration, auto-delegation, sparc-methodology |
You can extend these mappings by editing the pre-task hook configuration. Teams frequently add project-specific mappings — routing "billing" to their Stripe integration skill, or "email" to their Resend templates skill. The system is designed to grow with your workflow. Check the design tools page for skills focused on visual development workflows.
The pre-built skills cover common patterns. But the highest-value skills are the ones you write yourself — tailored to your codebase, your conventions, your hard-won lessons. A custom skill captures institutional knowledge that no public skill can replicate.
The structure is straightforward. A SKILL.md file needs four sections:
# Skill Name
## When to Use
Triggers: [keywords that should activate this skill]
Context: [what kind of task this applies to]
## Instructions
1. [Step-by-step procedure]
2. [Specific patterns to follow]
3. [Quality checks to run]
## Anti-Patterns
- [Things to explicitly avoid]
- [Common mistakes in this domain]
## Examples
[Before/after showing the skill applied correctly]When Claude encounters a pattern that works three times in a row, the self-improvement loop in the AI Brain Pro automatically suggests extracting it into a new skill. You review and approve. The next time that pattern is needed, the skill loads automatically instead of you re-explaining the approach. This is how the system gets smarter over time — learned patterns become reusable instructions.
We reviewed over 400 skills for this ranking. Not all of them deserved a recommendation. Some common failure patterns in low-quality skills:
Overly generic instructions
Skills that say "write clean code" or "follow best practices" without specifying what those practices are. If a skill does not change Claude's output compared to no skill at all, it is wasting context tokens.
Outdated framework versions
Skills referencing React class components, Next.js Pages Router, or Tailwind CSS v3 configuration patterns. The ecosystem moves fast. Skills need active maintenance.
Context bloat
Skills over 500 lines that dump entire documentation sections into context. Effective skills are concise — under 200 lines of high-signal instructions. Length does not equal quality.
The 152 skills in this ranking passed all three filters: specific enough to change output, current with 2026 tooling, and concise enough to leave room for actual work in the context window.
The AI Brain Pro includes every skill ranked in this article — plus the full 8-tier memory architecture, 109 pre-configured agents, lifecycle commands, hooks, and the self-improvement loop that keeps getting smarter.
Drop it into your project. Skills auto-load on every task. No configuration required.
Get AI Brain Pro — $97One-time purchase. 152 skills included. Lifetime updates.