14 Best Claude Code Skills for Developers in 2026

TL;DR: Best Claude Code skills

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 specific, reusable instructions that activate when the skill matches the task provided. Instead of re-explaining my preferences and workflows, I can define them once in a SKILL.md file and Claude picks them up automatically. Since Anthropic officially launched skills in October 2025, there are now thousands of skills for everything from accessibility auditing to video generation code.

For developers, Claude Code skills help you "install" another team's expertise into your workflow so that you're not starting from scratch. Once you start installing skills, you'll quickly realize that not all skills were created to the same standard. They're not detailed enough in the description or trying to do too many things. You might also end up having more skills than you actually need, which causes token overhead. Meanwhile, figuring out which skills are worth keeping is time consuming.

Having tested hundreds of skills, here are the 14 best Claude Code skills that I use today and recommend to every developer. The first 8 are core skills to run on every project, and the remaining 6 can be used when the job calls for them.

After months of trying out different skills, the ones that do and don't work share a clear pattern.

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.

My recommended skills are split into two groups: the first 8 are the core set I keep on across every project and the remaining 6 are situational depending on the task.

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 useful, planning in Claude Code and then passing the handoff doc to multiple Codex worktrees for parallel implementation:

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. If a question can be answered by reading the codebase, Claude reads it and moves on rather than asking you.

It's also 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. 1.1M installs. Matt Pocock's skills collection has 255k+ 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.

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 (now 210k+ stars), 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

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. 210k+ 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. It encodes the design direction that stops Claude's 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 for Claude is the biggest community-built skill library in the ecosystem (280k+ GitHub stars, 25k+ 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.

As a Superpowers Claude Code skill, 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.

The Developer Index is a purpose-built index for coding agents: GitHub issues, merged pull requests, READMEs, and curated documentation sites, addressable by natural-language question.

The problem it solves: a general web search returns tutorial blog posts when what you actually needed was the specific pull request that changed an API contract, the README passage that documents a config flag, or the issue where a bug was reported and fixed. The Developer Index skill points Claude at those primary sources first.

Filter by result type (doc, issue, pull_request, readme), by repos or sources, or by repository attributes (language, topic, license, min_stars, archived, fork). Each result carries a stable id like issue:owner/repo#123 plus its matched passages in markdown, so tables and code blocks survive.

Install (Developer Index skill):

npx -y firecrawl-cli@latest setup developer-index

Runs keyless for evaluation; add an API key for higher rate limits.

Example prompts:

"Find the PR where retry behavior was changed in openai/openai-python"
"Which passage of the Next.js README documents the app router?"
"Show me open issues in facebook/react tagged bug, language TypeScript"

This is a Capability Uplift skill.

The wider Firecrawl skill and CLI

The Developer Index is one skill in the Firecrawl CLI. One install command gives Claude the rest of the web-data toolkit built for agents (results write to files rather than context, JS rendering is handled, every command maps to how agents think about web work):

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

--all installs to every detected AI coding agent on the machine. --browser opens browser authentication so the API key connects without copy-paste. Also at claude.com/plugins/firecrawl.

Other commands Claude gets:

• firecrawl scrape: clean markdown from any page, JS-heavy sites included
• firecrawl search: web search with scraped results in one step
• firecrawl interact: scrape then interact via natural language or Playwright, with a live view stream
• firecrawl crawl: follow links across an entire site
• firecrawl map: list every URL on a domain
• firecrawl research: autonomous multi-step research

Pros: Developer Index returns primary sources (issues, PRs, READMEs) rather than SEO-ranked blog posts. The wider CLI posts 80%+ content recall on benchmark evaluations against every other scraping tool tested. File-based output keeps context lean.

Cons: Heavy ongoing use needs a key and consumes credits.

Full Developer Index docs: docs.firecrawl.dev/features/developer. CLI reference: docs.firecrawl.dev/cli.

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. 21k+ 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.

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.

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%. 100k+ 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. For the full picture of systematic Claude Code token efficiency, from path-scoped rules to MCP overhead control to model routing, Firecrawl's 12-technique guide benchmarks each approach and shows 77–91% cost reduction across methods.

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.

The rest of the list is scoped to specific work. Install when the job comes up; skip when it doesn't. Every one still saves time on its own turf, they're just narrower in trigger surface than the core set.

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, along with the other Vercel skills covered below: 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.

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.

Skills solve the core problem with AI coding assistants: they forget everything between sessions. The combination that's changed my Claude Code workflow most: Firecrawl for web research during development, Frontend Design for UI work, and React Best Practices for performance awareness. 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 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 Claude skills and Codex skills across the ecosystem, our best Codex skills guide covers the top OpenAI Codex skills worth installing, and for OpenCode users the best OpenCode skills roundup covers the top skills for Anomaly's model-agnostic terminal agent.

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. Both show up in our wider roundup of best GitHub repos for AI developers.

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 our full list of MCP servers for developers covers the servers themselves. 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.