Best Claude Code Skills to Try in 2026

P.S: Check out how we built a Claude Skills generator using Firecrawl's Agent endpoint, which generates complete skill files from any documentation URL.

Claude Code skills are the piece of the ecosystem that makes Claude genuinely reusable. Instead of re-explaining my preferences and workflows every session, I define them once in a skill file and Claude picks them up automatically. Skills extend Claude's capabilities in a way that feels natural. They activate when the task matches, stay out of the way when it doesn't.

The ecosystem has exploded since Anthropic officially launched skills in October 2025. There are now thousands of skills across official repositories, community collections, and niche toolkits for everything from accessibility auditing to video generation code. Figuring out which ones are actually worth installing has taken real experimentation.

These are the best Claude Code skills I'd hand someone starting today. Eighteen skills I actually use, covering web data access, UI quality, code performance, document handling, security, agent orchestration, video generation, and session management.

Claude Code skills are directories containing a SKILL.md file and optional supporting scripts or resources. The SKILL.md file starts with YAML frontmatter defining the skill's name and description, followed by markdown instructions that Claude follows when the skill activates.

What makes them different from system prompts or custom commands is how they load. At startup, Claude scans all available skills and reads only the name and description from each one, using roughly 100 tokens per skill. When you give Claude a task, it checks whether any skills match. If one does, it loads the full instructions. If no skill applies, nothing loads and your context stays clean.

Skills are also an open standard. The Agent Skills specification is adopted by Claude Code, OpenAI Codex CLI, Cursor, Gemini CLI, and GitHub Copilot. A skill you write or install works across all of these tools without modification.

There's an important distinction worth understanding before you start installing things. In his breakdown of Claude Code skills, Nate Herk defines two categories that change how you think about building and choosing them.

Capability Uplift skills give Claude abilities it doesn't have on its own. Before the skill, Claude can't do the task. After installing it, the skill teaches Claude new capabilities. Web scraping with the Firecrawl skill, creating real PDF files, running browser tests through Playwright: these are all Capability Uplift. Claude couldn't do them reliably before.

Encoded Preference skills are different. Claude already knows how to do the underlying task. The skill encodes your team's specific way of doing it. NDA reviews, weekly status updates, commit message formats, code review checklists: Claude can write all of these, but your skill captures the exact process and preferences your team follows so Claude doesn't have to guess every time.

Both types load progressively and trigger contextually. But knowing which kind you need changes how you think about building or choosing skills. If Claude keeps producing generic output for a task it technically "knows," an Encoded Preference skill is probably what's missing.

This distinction also matters for avoiding AI slop, the generic, predictable output that makes AI-generated work feel interchangeable. Encoded Preference skills capture the specific choices that make your work yours. Capability Uplift skills open up workflows that weren't possible before.

There are two scopes to install skills at:

• Personal skills installed to ~/.claude/skills/ are private and available across all your projects
• Project skills installed to .claude/skills/ in a repository are shared with everyone who clones it

For a deeper walkthrough of how skills work, including how to build one from scratch, check out How to Create a Claude Code Skill.

After working through hundreds of skills across the ecosystem, the ones that actually work share a clear pattern. And so do the ones that don't.

Signs a skill will work well:

• The description reads like a routing rule. Bad: "Helps with documents." Good: "Use when the user asks to extract form fields, fill, redact, or parse tables from a PDF file." The description is what Claude pattern-matches against at startup. Vague descriptions produce vague activation or no activation at all.
• Code does the deterministic work. The model shouldn't sort lists, parse PDFs, or validate schemas. Those jobs belong in bundled scripts: cheaper, repeatable, no hallucination risk.
• Lean SKILL.md, fat reference.md. The core instructions should fit on a phone screen. Push edge cases and deep context into companion files that only load on demand. A lean body means faster activation and lower token cost when the skill isn't relevant.
• One skill, one job. Skills that try to do five things trigger at the wrong moment and confuse Claude's routing. Split compound workflows into focused skills.
• Examples over rules. Three worked examples beat twenty bullet-pointed constraints every time. Claude generalizes from concrete examples better than it follows abstract rule lists.

Signs a skill will cause problems:

• A 4,000-token SKILL.md that loads on every adjacent task and burns context regardless of relevance.
• Vague triggers like "use this for productivity tasks." Productivity is not a category. Claude cannot route to it reliably.
• Self-reported metadata: skills that claim capabilities their bundled code cannot actually deliver.
• Undocumented network calls baked into scripts. Always read the full SKILL.md and audit every bundled script before installing community skills from less-trusted sources. The anthropics/skills repository and partner skills from Vercel, Trail of Bits, and Remotion are safe defaults.
• No examples. If you cannot infer the use case from the SKILL.md, neither can Claude.

Here are the eighteen I keep installed and actually reach for.

The Firecrawl skill gives Claude reliable access to web data without any manual setup.

When Claude needs to pull information from the web, most default tools fall apart on JavaScript-heavy sites or return messy HTML that's hard to reason about. The Firecrawl skill solves this by teaching Claude how to install and use the Firecrawl CLI on its own. After one install command, Claude has a complete web data toolkit it can use autonomously.

The Firecrawl CLI is specifically designed for AI agents. It writes results to files rather than dumping everything into the context window, handles JavaScript rendering automatically, and exposes commands that map directly to how agents think about web tasks.

This is a Capability Uplift skill. Claude simply cannot do reliable web scraping at scale without it.

Install:

npx -y firecrawl-cli@latest init --all --browser

The --all flag installs the Firecrawl skill to every detected AI coding agent on your machine. The --browser flag opens browser authentication so you can connect your API key without copying it manually.

Also available directly at claude.com/plugins/firecrawl. Get a free API key at firecrawl.dev/app/api-keys.

Commands Claude gets access to:

• firecrawl scrape: Clean markdown from any page, even JavaScript-heavy sites
• firecrawl search: Web search with scraped results in one step
• firecrawl interact: Scrape a page then interact with it via natural language prompts or Playwright code — click buttons, fill forms, extract dynamic content, with a live view stream you can embed or control
• firecrawl crawl: Recursively follow links across an entire site
• firecrawl map: Discover all URLs on a domain

Example:

"Scrape the changelog at https://docs.example.com/changelog and summarize what changed in the last 30 days. Save the output to changelog-summary.md"
 
"Search for the top 5 competitors to our product and extract their pricing pages into a comparison table"

Pros: Firecrawl delivers over 80% content recall on benchmark evaluations, outperforming every other scraping tool tested. JavaScript rendering and dynamic content are handled automatically. The file-based output keeps context efficient so Claude isn't burning tokens processing entire page dumps. The browser command opens the full range of interactive web automation.

Cons: Requires an API key and consumes credits on heavy usage. The free tier (1,000 credits per month) covers substantial testing but production workflows may need a paid plan.

Full documentation and CLI reference at docs.firecrawl.dev/cli. If you're building agents that need web data as part of a larger workflow, also read our guide on the Claude Agent SDK with Firecrawl.

Full reference at skills.sh/firecrawl/cli.

Matt Pocock's handoff skill compresses your current Claude Code session into a structured markdown document so you can continue the work in a fresh session, or pass it to a different agent entirely.

The problem it solves is context drift. As discussed on HN, sessions nearing compaction limits don't just slow down, they get dumber. After roughly 120k tokens, attention relationships strain and response quality degrades. /handoff gives you a clean exit before you hit that wall: it generates a document containing the purpose of the next session, relevant context from the current one, suggested skills to invoke, and pointers to existing artifacts, without duplicating file content.

The difference from /compact is intent. Compact keeps you in the same thread with a compressed summary. Handoff is for moving on: to a new session, a fresh worktree, or a completely different agent. Ben Holmes captured the pattern that makes this genuinely powerful, planning in Claude Code and then passing the handoff doc to multiple Codex worktrees for parallel implementation:

This is a Capability Uplift skill. Claude Code can produce summaries on request, but the handoff skill generates a structured, purpose-built context transfer document with the exact fields a receiving session needs to pick up cleanly.

Install:

npx skills add mattpocock/skills skill=handoff -y -g

Example:

"Create a handoff for this session before I run out of context"
"Handoff — I want to continue this in a new session"
"Generate a handoff doc so I can delegate the implementation to Codex"

Pros: Keeps sessions focused by giving you a deliberate exit point. The handoff document is more purposeful than a compaction summary: you control what the next session needs to know. Works cross-agent, letting you plan in Claude Code and implement in Codex, or split a large task across parallel worktrees.

Cons: The generated document goes to your OS temp directory by default, so commit it if you want a permanent record. Most useful when deliberately splitting work across sessions or agents; less necessary for single-threaded sessions that compact naturally.

Full reference at aihero.dev/skills-handoff.

Matt Pocock's grill-me skill interviews you relentlessly about every aspect of a plan until you reach shared understanding.

The skill went viral on X recently, with developers sharing how it fixes the most common failure mode in agentic coding: Claude charging ahead with wrong assumptions before you had a chance to correct them.

The SKILL.md instruction is direct: "Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer." If a question can be answered by reading the codebase, Claude reads it and moves on rather than asking you.

This is a design review tool. Use it before you write code, not after. The questions surface implicit assumptions, dependency chains between decisions, and gaps in your plan that seem obvious until you try to articulate them. Claude's recommended answers move the session forward rather than leaving you stuck at each question with no direction.

Install:

npx skills add https://github.com/mattpocock/skills --skill grill-me

Example:

"Grill me on this feature spec before I start building"
"Run grill-me on my plan for the auth refactor"
"Walk me through every decision in this architecture before I commit to it"

Pros: Surfaces the assumptions and dependency chains in your plan before they become bugs. Claude's recommended answers move the session forward rather than just blocking you with questions. 156.2K installs. Matt Pocock's skills collection has 87.3K GitHub stars.

Cons: Requires an actual plan or design to stress-test. "I want to build X" is too vague to grill effectively. Prepare a written spec or description before invoking the skill. The session is open-ended by design, not a checklist with a fixed number of questions.

One developer shared how grill-me completely changed how they plan with Claude Code. Their before: give Claude a prompt, get a plan built on wrong assumptions, spend the next hour correcting and repeating. Their after: run $grill-me, Claude asks questions one by one, decisions get made together including context they hadn't considered — until there's shared understanding, then Claude implements with far fewer surprises.

Reddit: "I tried the grill-me skill and it completely changed how I plan"

Full reference at skills.sh/mattpocock/skills/grill-me.

The most starred Claude Code behavioral skill on GitHub, encoding Karpathy's viral observations about LLM coding pitfalls into four hard rules.

When Andrej Karpathy posted his frustrations with AI coding agents in January 2026, it went viral immediately. Developer Forrest Chang turned the observations into a single CLAUDE.md file with four behavioral principles. The repo hit 144k stars in weeks, making it one of the fastest-growing AI workflow repositories ever — all from a single file with zero runtime dependencies.

The skill targets the three failure patterns Karpathy called out directly: agents making silent wrong assumptions and charging ahead without checking, over-engineering that turns 50 lines into 500, and orthogonal changes that modify code the agent was never supposed to touch.

This is an Encoded Preference skill. Claude already knows how to code. The skill encodes the behavioral guardrails that stop it from confidently charging ahead with wrong assumptions or bloating a 50-line solution into 500.

Install:

Option A: Claude Code Plugin (recommended)

/plugin marketplace add forrestchang/andrej-karpathy-skills
/plugin install andrej-karpathy-skills@karpathy-skills

Option B: Add to CLAUDE.md (per-project)

curl -o CLAUDE.md https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md

The four principles:

• Think Before Coding: State assumptions explicitly. If multiple interpretations exist, present them. Don't pick one silently and run with it.
• Simplicity First: Minimum code that solves the problem. No features beyond what was asked. No abstractions for single-use code. If 200 lines could be 50, rewrite it.
• Surgical Changes: Touch only what you must. Don't improve adjacent code or formatting. Match existing style, even if you'd do it differently. If you notice unrelated dead code, mention it — don't delete it.
• Goal-Driven Execution: Define success criteria and loop until verified. "Add validation" becomes "Write tests for invalid inputs, then make them pass."

Example:

"Fix the bug where empty emails crash the validator"

Without the skill: Claude fixes the bug and also adds docstrings, reformats quotes, adds type hints, and rewrites adjacent logic. With the skill: three lines changed, nothing else touched.

Pros: The most battle-tested behavioral guardrail in the ecosystem. 144k stars reflects that every developer using AI coding agents has hit these exact failure modes. The four principles are tight enough to fit in context without crowding out project-specific instructions. Works across Claude Code, Cursor, and Copilot. Designed to be merged with your existing CLAUDE.md rather than replacing it.

Cons: Biases toward caution over speed. For trivial tasks (simple typo fixes, obvious one-liners), the full rigor adds friction without benefit. Use judgment on small changes, and layer your own project-specific sections on top for best results.

Repo: github.com/multica-ai/andrej-karpathy-skills. Full reference at skills.sh/multica-ai/andrej-karpathy-skills.

The Frontend Design skill gets Claude past generic AI slop to distinctive, production-grade UI.

Anyone who has used Claude Code to build UI knows the pattern: Inter font, purple gradient, card layout, safe neutrals. It works, but it looks like AI output. This is the textbook definition of AI slop: technically correct but visually interchangeable with every other AI-generated interface. The Frontend Design skill, maintained officially by Anthropic, pushes Claude to make deliberate aesthetic choices before writing any code.

The skill explicitly bans a list of overused fonts (Inter, Roboto, Arial, Space Grotesk) and pushes Claude to commit to a specific visual direction (brutalist, maximalist, retro-futuristic, editorial, whatever fits the project), then executes that direction with attention to typography pairings, color systems, motion, spatial composition, and backgrounds.

This is an Encoded Preference skill. Claude can technically write CSS. The skill encodes the design direction that stops the output from looking generic.

Install:

npx skills add https://github.com/anthropics/skills --skill frontend-design

Example:

"Build a landing page for a productivity app. Typographic focus, dark editorial aesthetic."
"Create a music player interface. Maximalist, tactile, 90s hardware-inspired."

Pros: Makes a noticeable difference on creative projects. The skill pushes Claude to think through visual identity before generating code, which produces much more intentional results. Works across HTML/CSS/JS, React, and Vue. With over 110k weekly installs across Claude Code, Codex, and Gemini CLI, it's one of the most widely adopted skills in the ecosystem.

Cons: The bias toward bold aesthetics doesn't fit every project. Internal tools and enterprise dashboards often need consistency over creativity. Pair it with the Web Design Guidelines skill below for quality checks, or skip it when you're building to a strict design system.

Also relevant: Claude Code for Marketers covers how non-engineers are using Claude Code with skills like this to build landing pages and campaign assets without a developer.

Full reference at skills.sh/anthropics/skills/frontend-design.

Superpowers is the most complete multi-agent development workflow available as a Claude skill.

Obra's Superpowers collection is the biggest community-built skill library in the ecosystem (40.9k GitHub stars, 3.1k forks). Rather than a single skill, it's a composable framework that structures the full software development lifecycle through a series of skills that chain together: brainstorming, git worktree setup, implementation planning, subagent-driven execution, TDD, and code review before merging.

The core workflow walks Claude through refining an idea through structured questions, committing to a design, breaking it into small implementable tasks, dispatching fresh subagents per task with two-stage review, enforcing RED-GREEN-REFACTOR test discipline, and presenting merge options with branch cleanup. Skills trigger automatically. Once Superpowers is installed, Claude checks for relevant skills before any task.

This is both a Capability Uplift and Encoded Preference skill. It adds multi-agent orchestration capabilities while encoding a specific development methodology.

Install:

npx skills add obra/superpowers

Key skills included:

• /brainstorm: Refines ideas through structured questions, saves a design doc
• /write-plan: Breaks approved designs into 2-5 minute tasks with exact file paths and verification steps
• /execute-plan: Dispatches fresh subagents per task with spec compliance and code quality review
• using-git-worktrees: Creates isolated branches and verifies a clean test baseline before any code is written
• test-driven-development: Deletes any code written before a failing test exists

Example:

/brainstorm "I want to add a real-time collaboration feature to my note-taking app"

Claude will ask clarifying questions, refine the design, save a spec, and offer to create an implementation plan. Each task then runs in a fresh subagent context.

Pros: The subagent-driven approach prevents context drift on long tasks. TDD enforcement means you always have tests before code. The code review step before merging catches issues that slip through autonomous coding sessions. One of the few skill collections with proper multi-hour autonomous capability baked into the workflow.

Cons: The structured workflow requires setup time. Vague ideas produce thrashing. Best for projects with clear requirements where you want systematic execution rather than exploratory prototyping.

Repo: github.com/obra/superpowers. Full reference at skills.sh/obra/superpowers.

This skill audits your UI code against 100+ rules covering accessibility, performance, and UX.

Where the Frontend Design skill focuses on creative direction, this Vercel skill is a quality gate. It fetches the latest Web Interface Guidelines from a canonical source and checks your code against every rule, outputting findings in a terse file:line format you can act on immediately.

The guidelines cover the things that get missed under deadline pressure: proper ARIA attributes, visible focus states, labeled inputs, touch target sizes, reduced-motion support, semantic HTML, keyboard navigation, heading hierarchy, and dozens more. This is what a thorough code review for UI quality actually looks like, automated.

The skill always fetches the current version of the guidelines before running, so you're checking against the latest standard.

This is an Encoded Preference skill. It encodes Vercel Engineering's UI/UX standards so Claude applies them consistently across your codebase.

Install:

npx skills add https://github.com/vercel-labs/agent-skills --skill web-design-guidelines

Example:

/web-design-guidelines src/components/**/*.tsx
 
"Review my UI code for accessibility issues"
"Audit this form component against web interface best practices"
"Check this page for WCAG compliance issues"

Pros: Catches real usability issues that are easy to miss when moving fast. The rules are maintained by Vercel Engineering and stay current. With 133k weekly installs, it's one of the most widely adopted UI/UX standards across Claude Code, Cursor, Codex, and Copilot.

Cons: Focused on compliance and correctness rather than creativity. Doesn't replace human design judgment for complex interaction patterns or brand-specific design decisions.

Full reference at skills.sh/vercel-labs/agent-skills/web-design-guidelines. Repo: github.com/vercel-labs/agent-skills.

This skill applies 57 performance optimization rules to React and Next.js code, prioritized by impact.

Performance is a UX problem. A beautifully designed interface that takes 4 seconds to become interactive is a bad experience regardless of how it looks. The React Best Practices skill from Vercel Engineering encodes 57 rules across 8 categories, ordered by actual impact: eliminating request waterfalls first, then bundle size, server-side performance, data fetching, re-renders, rendering, JavaScript performance, and advanced patterns.

The ordering matters. Too many developers (and too many AI assistants) jump to useMemo and React.memo when the real bottleneck is a waterfall of sequential API calls or a barrel file importing an entire icon library. This skill makes Claude address the high-impact issues first.

This is an Encoded Preference skill that encodes Vercel Engineering's performance priorities so Claude applies them by default.

Install:

npx skills add https://github.com/vercel-labs/agent-skills --skill vercel-react-best-practices

What Claude applies:

• Eliminate request waterfalls using Suspense boundaries to stream content
• Avoid barrel imports that pull in entire libraries
• Use next/dynamic for heavy components
• Apply CSS content-visibility for long lists
• Subscribe to derived state booleans, not raw values

Example:

"Review this component for performance issues"
"Refactor this page to eliminate data fetching waterfalls"
"Why is this component re-rendering unnecessarily?"

Pros: Gives Claude the same performance knowledge that Vercel Engineering applies internally. Catches real bottlenecks instead of spending time on micro-optimizations that don't move the needle.

Cons: Optimized for Next.js App Router patterns specifically. If you're not using the App Router, some rules won't apply directly.

Full reference at skills.sh/vercel-labs/agent-skills/react-best-practices.

This skill replaces boolean prop proliferation with compound components, context providers, and clean component APIs.

Boolean prop proliferation is one of the most common design system problems: isCompact, showHeader, isRounded, hasBorder, isHighlighted, all on one component. It makes components hard to understand, test, and extend. The Composition Patterns skill from Vercel Labs teaches Claude to use patterns that scale instead.

The skill covers compound components with shared context, state decoupling via clean interfaces, explicit variant components instead of boolean modes, and React 19+ patterns like skipping forwardRef.

Install:

npx skills add https://github.com/vercel-labs/agent-skills --skill composition-patterns

What Claude learns to apply:

• Compound component patterns (like <Select>, <Select.Trigger>, <Select.Content>)
• State decoupled from implementation via provider interfaces
• Explicit variants: <Alert.Destructive> instead of <Alert isDestructive>
• Children over render props for composition
• React 19 use() hook instead of useContext()

Example:

"Refactor this component to use compound components instead of boolean props"
"Design a flexible API for this dropdown component"
"Review this component library for composition anti-patterns"

Pros: Makes component APIs that other developers can actually extend without reading the source. Especially valuable when building a design system or shared component library where the API surface matters as much as the implementation.

Cons: Higher upfront complexity on simple components. The pattern pays off most when components need to support multiple configurations and consumers.

Full reference at skills.sh/vercel-labs/agent-skills/composition-patterns.

Anthropic's official document skills give Claude the ability to create, edit, and parse real document files.

One of the most practical skill collections in the official Anthropic repository is the set of document skills. These are Capability Uplift skills. They don't generate text descriptions of documents, they execute Python scripts to actually create and manipulate real files that you can open and send.

The four skills cover:

• PDF: Extract text and tables, create new PDFs, merge and split documents, handle forms
• DOCX: Create and edit Word documents with tracked changes, comments, and formatting preservation
• XLSX: Create and analyze Excel spreadsheets with formulas, formatting, and data visualization
• PPTX: Create and edit PowerPoint presentations with layouts, templates, and charts

Install:

npx skills add https://github.com/anthropics/skills --skill pdf

Example:

"Extract the pricing table from this PDF and create an Excel file comparing the tiers"
"Generate a monthly report as a formatted Word document with the data from our API"
"Create a presentation summarizing the Q1 results from this spreadsheet"

Pros: Handles real document workflows, not just text generation. Being able to chain these together (pull data from a PDF, process it, output to Excel) opens up practical automation for document-heavy processes. Official Anthropic skills with proper maintenance.

Cons: Requires Python dependencies for the underlying scripts. Complex formatting and multi-page layouts may still need manual review before sending.

Full reference at skills.sh/anthropics/skills/pdf (and docx, xlsx, pptx).

Also from the Anthropic skills repo: doc-coauthoring. For long-form writing rather than file generation, the doc-coauthoring skill takes a collaborative approach. It starts each writing task by building shared context: asking about audience, scope, and tone, getting sign-off on an outline, then drafting section by section with your input throughout. The output reads like a human wrote it because the process required human guidance at every stage. Use it for technical specs, runbooks, onboarding guides, or any document where generic output won't do. Install with npx skills add https://github.com/anthropics/skills --skill doc-coauthoring.

The webapp-testing skill lets Claude test your local web application using a real browser.

This official Anthropic skill gives Claude browser control via Playwright to interact with local apps during development. Instead of writing test scripts, you describe what you want tested and Claude runs it in a visible browser window where you can watch the interaction.

It's particularly useful for testing flows that involve authentication, JavaScript-rendered content, or complex user interactions that are hard to test statically. This is a Capability Uplift skill. Claude gains the ability to interact with live browser state rather than reasoning about static code.

Install:

npx skills add https://github.com/anthropics/skills --skill webapp-testing

Example:

"Test the login flow at http://localhost:3000. Try valid and invalid credentials and verify the error messages appear correctly"
"Run through the checkout flow on my local app and check that form validation catches missing fields"
"Navigate through all the pages in the sidebar and make sure none throw JavaScript errors"

Pros: Catches UI bugs that static analysis misses. Real browser testing surfaces JavaScript errors, timing issues, and interaction problems that only appear in a live environment. Being able to log in manually and then hand off to Claude for automated testing is genuinely useful on authenticated flows.

Cons: Requires Playwright installed locally. Browser sessions consume more tokens than static analysis. Test sessions can be brittle if app state changes unexpectedly between runs.

Full reference at skills.sh/anthropics/skills/webapp-testing.

Trail of Bits security skills bring professional-grade static analysis and vulnerability detection into Claude Code.

Trail of Bits is a security research firm known for rigorous vulnerability research and tools like Slither and Echidna. Their Claude skills package brings that expertise into Claude Code as automated security workflows. The collection covers CodeQL and Semgrep static analysis, variant analysis for finding related vulnerabilities across a codebase, and structured code auditing methodologies.

These are not basic security checklists. They encode the workflows Trail of Bits actually uses for professional security audits. This makes them Capability Uplift skills. They give Claude the ability to run real static analysis tools rather than just describing vulnerabilities.

Install:

npx skills add trailofbits/skills

What the skills cover:

• Static analysis with CodeQL and Semgrep
• Variant analysis to find related vulnerabilities across a codebase
• Structured code auditing following professional audit methodology
• Vulnerability detection patterns for common security issues

Example:

"Run a security audit on the authentication module"
"Find variants of this SQL injection pattern across the codebase"
"Analyze this smart contract for common vulnerabilities"

Pros: Brings security expertise from a firm that does this professionally. Having Claude follow structured audit methodologies rather than ad-hoc checks produces more thorough results. Pairs well with the Security Guidance plugin for preventative checks during active development.

Cons: Requires CodeQL or Semgrep installed depending on which skills you use. Security analysis is a deep domain. The skills improve Claude's approach but still require developer judgment on findings. Not every vulnerability category will be relevant to every project.

Repo: github.com/trailofbits/skills. Full reference at skills.sh/trailofbits/skills.

The Remotion skill gives Claude deep domain knowledge for building programmatic videos with React.

If you're generating videos from code, Remotion is the standard, and Claude's out-of-the-box knowledge of it can be shallow. The Remotion Best Practices skill, maintained by the Remotion team, loads specialized rules for animations, timing, audio, captions, 3D, and more, ensuring Claude generates correct, idiomatic Remotion code every time.

This is a Capability Uplift skill. Without it, Claude can write Remotion code but frequently gets interpolation curves, audio trimming, and composition patterns wrong. With it, Claude knows exactly what to reach for.

Install:

npx skills add https://github.com/remotion-dev/skills --skill remotion-best-practices

What the skill covers:

• Animations and timing: interpolation curves, spring animations, easing, sequencing, and transitions
• Audio and captions: importing audio, trimming, volume control, subtitles
• Media handling: videos, images, GIFs, Lottie, fonts, and transparent video rendering
• 3D content: Three.js and React Three Fiber integration inside Remotion compositions
• Charts and data viz: bar, pie, line, and stock chart patterns
• Advanced patterns: dynamic metadata, parametrizable videos with Zod schemas, ElevenLabs voiceover

Example:

"Create a Remotion composition that animates a bar chart with spring physics and fades out at the end"
"Add voiceover audio to this Remotion video and sync the captions to the transcript"

Pros: With 117k weekly installs, it's one of the most widely used official skills in the ecosystem. Activates automatically when Claude detects Remotion code in context. Loads only relevant rule files on demand to stay token-efficient.

Cons: Narrowly scoped to Remotion. If you're not building programmatic video, there's no reason to install it.

When the skill dropped in February 2026, people couldn't stop raving about it:

Full reference at skills.sh/remotion-dev/skills/remotion-best-practices.

You don't have to stick to pre-made skills. No two people's workflows and day-to-day tasks are the same, which means the most useful skill you'll ever install is often one you built yourself.

Anthropic recently launched the Skill Creator, and it's the easiest way to build your own Claude Code skills interactively.

Once you've been using skills for a while, you'll start noticing workflows you keep re-explaining to Claude. That's when building a custom skill is worth it. Anthropic's Skill Creator walks you through an interactive Q&A that generates a complete skill directory with proper SKILL.md structure, frontmatter, and instructions.

The skill asks about the workflow you want to automate, the trigger conditions, any scripts or reference files needed, and how the skill should handle edge cases. It then generates the full skill structure ready to use.

Available directly as a plugin at claude.com/plugins/skill-creator.

Install:

npx skills add https://github.com/anthropics/skills --skill skill-creator

Use it:

"Use the skill-creator to help me build a skill for running database migrations safely"
"Help me create a skill for our team's code review checklist"
"Build a skill that enforces our commit message format and links to the right Linear ticket"

Pros: Removes the blank-page problem when building custom skills. The interactive Q&A surfaces edge cases you might not have considered. Generated skills follow the proper structure that loads efficiently and triggers reliably. This is also where the two types of skills distinction becomes useful. If you're encoding a team preference, the Q&A will surface the specific steps and edge cases that make your workflow unique.

Cons: Still requires you to know what workflow you want to encode. Vague ideas produce vague skills. The real value comes from identifying a repeatable task first, then using this skill to formalize it cleanly.

Full reference at skills.sh/anthropics/skills/skill-creator.

When Corey launched this collection, it was all the hype, and for all the right reasons.

Corey Haines built what is arguably the most comprehensive marketing-focused skill library in the ecosystem (12.9k stars, 1.9k forks). Rather than one skill, it's 32 skills organized into a full marketing stack: conversion optimization, copywriting, SEO, paid ads, analytics, retention, growth engineering, and sales operations. The skills cross-reference each other and all pull from a shared product-marketing-context file so Claude understands your product, audience, and positioning before doing anything.

The breadth is what makes it stand out. Most skill collections pick a lane. This one covers the entire funnel: from seo-audit and programmatic-seo at the top, through page-cro, signup-flow-cro, and onboarding-cro in the middle, down to churn-prevention, email-sequence, and revops at the retention end. There's even an ai-seo skill for optimizing content to appear in AI-generated answers.

Each skill encodes real conversion and growth methodology, not generic marketing advice. That's what earned it the reception it got when Corey shipped it:

This is a collection of Encoded Preference skills. Claude already knows marketing concepts; these skills make it apply the specific frameworks and workflows Corey's agency actually uses.

Install:

# All 32 skills
npx skills add coreyhaines31/marketingskills
 
# Just the ones you need
npx skills add coreyhaines31/marketingskills --skill page-cro copywriting seo-audit

Key skills:

• page-cro: Conversion optimization for any marketing page
• copywriting: Homepage, landing page, and feature copy
• seo-audit: Technical and on-page SEO review
• ai-seo: Optimization for AI search (AEO, GEO, LLMO)
• email-sequence: Automated lifecycle email flows
• cold-email: B2B cold outreach and follow-up sequences
• ab-test-setup: Experiment design and implementation
• analytics-tracking: GA4 and event tracking setup
• churn-prevention: Cancel flows, save offers, dunning

Example:

"Help me optimize this landing page for conversions"
"Write homepage copy for our web scraping API"
"Set up GA4 event tracking for signups and upgrades"
"Design a 5-email welcome sequence for new free users"

Honest take: As a marketer, I do see genuine value here. That said, I rarely use the skills as-is. Instead, I treat them as a starting point and tweak each one based on Firecrawl's specific positioning, audience, and tone. The copywriting and page-cro skills especially require tuning before they produce output that actually fits your brand. Fork the ones you want to customize, update the product-marketing-context file with your product details, and the whole collection gets significantly more useful.

Cons: 32 skills is a lot to install if you only need a few. The product-marketing-context setup step is required before most skills produce useful output. Skills are generalist by design, so vertical-specific products (developer tools, enterprise SaaS, consumer apps) will need customization.

Repo: github.com/coreyhaines31/marketingskills. Full reference at skills.sh/coreyhaines31/marketingskills.

Julius Brussee's Caveman skill cuts Claude Code output tokens by an average of 65% by stripping narration, filler, and pleasantries while keeping every technical fact and code block byte-for-byte intact.

The concept: when Claude explains a React re-render bug normally, it says "The reason your component is re-rendering is likely because you're creating a new object reference on each render cycle. I'd recommend using useMemo to memoize the object." (69 tokens). In caveman mode: "New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo." (19 tokens). Same fix. 75% fewer words.

A March 2026 paper found that constraining large models to brief responses improved accuracy by 26 points on certain benchmarks. Caveman doesn't make Claude dumber: it makes Claude's mouth smaller while keeping its brain the same size.

This is an Encoded Preference skill. Claude already knows the technical content. Caveman encodes the communication style.

Install:

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

Or just the core skill:

npx skills add mattpocock/skills --skill caveman -g

What you get:

• /caveman [lite|full|ultra|wenyan] — compress every reply at your chosen intensity; modes persist until you say "normal mode"
• /caveman-commit — conventional commit messages, ≤50 char subject, why over what
• /caveman-review — one-line PR review comments: L42: bug: user null. Add guard.
• /caveman-compress — rewrites your CLAUDE.md into caveman-speak, cutting ~46% of input tokens every session
• /caveman-stats — real session token usage, lifetime savings, and USD cost

Pros: 65% average output token reduction across benchmarks, range 22-87%. 68.1k GitHub stars. Works across Claude Code, Codex, Gemini CLI, Cursor, Windsurf, and 30+ other agents. The /caveman-compress companion shrinks your CLAUDE.md by ~46%, saving input tokens on every future session permanently.

Cons: Caveman output can feel jarring at first, especially for explanations you want in full sentences. The savings are highest in multi-turn sessions (where prompt cache kicks in) and lowest on single isolated prompts. Not worth installing if you mostly ask one-shot questions.

Repo: github.com/JuliusBrussee/caveman. Full reference at skills.sh/juliusbrussee/caveman.

Context Mode keeps Claude Code sessions productive for hours by filtering shell output noise before it reaches the context window and restoring your full state when Claude has to reset.

Every git status, npm test, and docker build command dumps raw output into context. After 30 minutes of active coding, most of what Claude is re-reading on every turn is command output junk rather than useful project context. That's what kills long sessions: not Claude running out of capacity, but Claude's attention diluted by accumulated noise.

Context Mode does two things. First, it intercepts verbose shell output and passes only the meaningful parts through to Claude's context. Second, it keeps a running session log of files edited, tasks in progress, and recent prompts. When Claude resets mid-session due to context limits, Context Mode restores the log automatically so work resumes exactly where it left off.

Sessions that used to die at the 30-minute mark now run for hours. The difference isn't model capability; it's what Claude is actually paying attention to.

This is a Capability Uplift skill. Claude Code doesn't have session memory by default. Context Mode adds it.

Install:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

Pros: Solves the most common long-session frustration: Claude forgetting what it was doing after a reset. 16.3k GitHub stars. Works across Claude Code, Gemini CLI, VS Code Copilot, JetBrains Copilot, and OpenCode.

Cons: Some output filtering is heuristic: occasionally clips verbose output you wanted Claude to see. Review the session log on complex multi-file tasks to verify context fidelity.

Repo: github.com/mksglu/context-mode.

Anthropic's internal code-simplifier plugin cleans up recently written code without changing what it does: readability improvements only, no logic changes.

This is the plugin Anthropic uses internally on the Claude Code team. Released publicly, it runs a focused cleanup pass on modified code: removes duplication, clarifies logic, flattens nested conditionals, and rewrites compact expressions into explicit readable alternatives. The constraint it enforces is absolute — never change behavior, only how behavior is expressed. It won't refactor your architecture or suggest structural changes. It cleans up the code you just wrote and moves on.

AI-assisted coding accumulates complexity fast: functions doing three things at once, abstractions that made sense when written and don't six weeks later. Code-simplifier addresses this as a systematic final step rather than a vague "clean this up" prompt.

Install:

/plugin marketplace add anthropics/claude-plugins-official
/plugin install code-simplifier@claude-plugins-official

Example:

"Use code-simplifier on the auth module I just built"
"Run the code simplifier on the changed files before I open this PR"
"Simplify the last three components we wrote this session"

Pros: Official Anthropic plugin maintained by the Claude Code team. The hard constraint against behavior changes makes it safe to run on production code before merging. Follows your project's conventions from CLAUDE.md so output stays consistent with your existing codebase style.

Cons: Requires reprocessing code that was already token-expensive to generate. Run it selectively on genuinely complex output rather than as a routine pass on every small change.

Repo: github.com/anthropics/claude-plugins-official.

Skills solve the core problem with AI coding assistants: they forget everything between sessions. You can explain your preferences, your stack, your conventions once, and Claude applies them every time without being reminded.

The combination that's changed my workflow most: Firecrawl for web research during development, Frontend Design for UI work, React Best Practices for performance awareness, and the Document skills for client deliverables. They don't conflict, they stack. Claude pulls the right ones for whatever the task is.

Understanding the two types helps you build a more intentional stack. Capability Uplift skills (Firecrawl, Document Skills, Webapp Testing) give Claude new abilities. Encoded Preference skills (Frontend Design, React Best Practices, Superpowers) make sure Claude executes the way you want rather than defaulting to generic patterns that produce AI slop.

One underused multiplier for skills in Claude Code: Routines. Configure a skill-driven workflow once, then promote it to a Claude Code Routine that triggers on a schedule, via API, or in response to a GitHub event. Nightly dependency upgrades, on-merge changelog generation, auto-triage of new issues: Skills define the workflow, Routines run it automatically. It's where skills stop being a parlor trick and start replacing cron scripts.

One thing worth calling out: skills aren't Claude-specific. The Agent Skills specification is an open standard, and every skill on this list works across Claude Code, OpenAI Codex CLI, Gemini CLI, Cursor, and GitHub Copilot without modification. Install once, use everywhere. If you are weighing which agent to use as your primary driver, the Claude Code vs Codex comparison covers the full picture on pricing, harness depth, and sandboxing. For Codex users specifically, the Firecrawl skill also solves Codex CLI's web browsing gap — Codex does not have live internet access by default, and the skill patches that without any MCP configuration. For a step-by-step guide to enabling Codex web search using Firecrawl, see the dedicated walkthrough. If you are looking for the best Codex skills across the ecosystem, our best Codex skills guide covers the top OpenAI Codex skills worth installing.

For discovering what's available, Vercel maintains skills.sh as a searchable directory of published skills across the ecosystem. It's the fastest way to find skills by category, author, or install count without digging through GitHub repos manually.

The community is still early but moving fast. The awesome-claude-skills repository on GitHub (13k stars) is a great curated list of top Claude Code skills, and the anthropics/skills repository is where to look for well-maintained, production-ready additions from Anthropic itself.

If you want to build your own, start with the Claude Code skill tutorial that walks through building a Firecrawl-powered skill from scratch. If you're looking for the broader ecosystem of plugins, MCP servers, and tools that work alongside skills, our guide on top Claude Code plugins covers what's worth installing there too. And if you're building more complex multi-agent workflows, our guide on the Claude Agent SDK with Firecrawl shows how to combine agents with reliable web data access.