Top 6 Skills for Claude Code in 2026 (TDD, Review, Frontend)

The must-have Skills

Here are the most popular and useful Skills in the Claude Code ecosystem in 2026. Each one transforms Claude into a specialized expert for a specific task. They're organized by category to help you find the one you need.

Development & Quality

TDD Guide

The TDD Guide Skill turns Claude into a test-driven development coach. It enforces strict discipline: write the test first, make it fail, then implement the minimum to make it pass.

# Invocation
/user:tdd-guide create an email validation function

Use cases:

• Implementing a new feature with solid test coverage
• Learning TDD on an existing project
• Refactoring legacy code by adding tests first

What the Skill does:

Code Reviewer

The Code Reviewer simulates a code review by a senior developer. It analyzes the current diff and produces a structured report with concrete suggestions.

# Review the current diff against main
/user:code-reviewer

# Review a specific diff
/user:code-reviewer develop

Use cases:

• Checking your code before creating a Pull Request
• Getting an automated second look on critical changes
• Training junior developers on code review best practices

What the Skill checks:

• Logic bugs and unhandled edge cases
• Security vulnerabilities (injection, XSS, CSRF)
• Performance issues (nested loops, N+1 queries)
• Compliance with project conventions (via CLAUDE.md)
• Test coverage of changes
• Duplicated code and refactoring opportunities

Debugging

The Debugging Skill structures the bug resolution approach. Instead of trial and error, Claude follows a systematic method to identify and fix the problem.

# Debug a specific error
/user:debugging TypeError: Cannot read property 'map' of undefined

# Debug with context
/user:debugging the contact form isn't submitting data

Use cases:

• Resolving runtime errors with a structured approach
• Investigating intermittent bugs
• Understanding unexpected behavior in complex code

What the Skill does:

1. Reproduce the problem (identify exact conditions)
2. Isolate the root cause (not the symptom)
3. Propose a minimal, targeted fix
4. Add a regression test
5. Verify no side effects are introduced

Architecture & Planning

Plan

The Plan Skill is your planning assistant for complex features. It breaks down a request into phases, identifies risks, and produces a detailed action plan.

# Plan a new feature
/user:plan add an OAuth2 authentication system

# Plan a migration
/user:plan migrate from REST to GraphQL

Use cases:

• Starting a complex feature without knowing where to begin
• Estimating development effort for a task
• Identifying dependencies and risks before coding
• Creating a technical roadmap for an epic

What the Skill produces:

• A concise PRD (Product Requirements Document)
• An ordered task list with dependencies
• Identified risks and mitigation strategies
• Files that will be created or modified
• A complexity estimate (S/M/L/XL)

Brainstorming

Brainstorming helps explore ideas and solutions from multiple angles. Claude adopts different perspectives to enrich the thinking process.

# Explore technical solutions
/user:brainstorm which database to choose for a real-time chat system

# Explore product approaches
/user:brainstorm how to improve the onboarding experience

Use cases:

• Choosing between multiple technical approaches
• Exploring creative solutions to a problem
• Preparing an RFC or technical proposal
• Evaluating trade-offs of an architecture

What the Skill does:

• Generates 3 to 5 distinct approaches
• Evaluates each approach against criteria (performance, maintainability, cost, complexity)
• Identifies the trade-offs of each solution
• Recommends the approach best suited to the project context

Tests & Security

E2E Testing

The E2E Testing Skill generates end-to-end tests for critical user journeys. It targets popular frameworks like Playwright and Cypress.

# Generate E2E tests for a journey
/user:e2e-testing registration and login flow

# Generate for a specific framework
/user:e2e-testing --framework playwright shopping cart

Use cases:

• Covering critical paths before a release
• Automating regression tests on main flows
• Generating tests for existing uncovered features

What the Skill produces:

// Sample output for a registration journey
import { test, expect } from "@playwright/test";

test.describe("User registration", () => {
  test("registration with valid data", async ({ page }) => {
    await page.goto("/register");
    await page.fill("[name=email]", "test@example.com");
    await page.fill("[name=password]", "SecureP@ss123");
    await page.fill("[name=confirmPassword]", "SecureP@ss123");
    await page.click("button[type=submit]");
    await expect(page).toHaveURL("/dashboard");
    await expect(
      page.getByText("Welcome")
    ).toBeVisible();
  });

  test("shows error with invalid email", async ({ page }) => {
    await page.goto("/register");
    await page.fill("[name=email]", "invalid-email");
    await page.click("button[type=submit]");
    await expect(
      page.getByText("Invalid email")
    ).toBeVisible();
  });
});

Security Review

Security Review analyzes your code from a security perspective. It identifies known vulnerabilities (OWASP Top 10) and suggests fixes.

# Global security audit
/user:security-review

# Targeted audit on a module
/user:security-review src/auth/

Use cases:

• Security audit before production deployment
• Verifying exposed API endpoints
• Reviewing secret and token management
• OWASP compliance for web applications

What the Skill checks:

• SQL and NoSQL injections
• XSS (Cross-Site Scripting) vulnerabilities
• Authentication and authorization issues
• Sensitive data exposure (API keys, tokens, passwords)
• Security misconfiguration (CORS, headers, CSP)
• Dependencies with known vulnerabilities (CVE)

Design & Frontend

Frontend Design

Frontend Design helps design and implement modern user interfaces. It integrates design system principles and accessibility best practices.

# Create a UI component
/user:frontend-design create a responsive pricing table component

# Improve an existing component
/user:frontend-design improve the Modal component's accessibility

Use cases:

• Creating accessible, responsive UI components
• Implementing a consistent design system
• Converting a Figma mockup to code
• Improving the UX of an existing component

What the Skill produces:

• A functional React/Vue/Svelte component
• Optimized Tailwind CSS styles for responsive
• Accessibility attributes (ARIA, focus management, contrast)
• Theme variants (light/dark mode)
• Component tests with Testing Library

Non-technical Skills

Claude Code isn't just for developers. These Skills turn Claude into a specialized assistant for everyday tasks: writing, organization, communication. No technical skills required.

Professional Email

Writes emails adapted to the recipient and context. The Skill identifies the right tone (formal, semi-formal, casual) and systematically offers both a concise and a detailed version.

/user:email-pro follow up with a client who hasn't responded to my quote in 10 days

Use cases:

• Client and vendor follow-ups
• Diplomatic responses to difficult requests
• Prospecting or sales follow-up emails
• Internal communication (announcements, information requests)

Download this skill

Document Summary

Produces a structured summary of any document: meeting notes, reports, articles, technical specifications. The summary includes key points, decisions, action items, and unclear areas.

/user:resume-document [paste text or indicate file path]

Use cases:

• Condensing a 2-hour meeting report into 10 lines
• Extracting decisions and actions from a long email thread
• Summarizing an article or report to share with the team
• Preparing a brief from multiple documents

Download this skill

Project Planning

Breaks down a project into phases, tasks, and milestones. Each task is estimated by effort (S/M/L/XL) with its dependencies. The Skill also identifies risks and the critical path.

/user:planning-project organize a new product launch, team of 5, deadline end of June

Use cases:

• Planning a sprint or quarter
• Breaking down a complex project before estimating
• Preparing a roadmap for leadership
• Organizing an event or launch

Download this skill

Presentation Builder

Creates structured slide deck content: catchy titles, key messages per slide, suggested visuals, and speaker notes. The Skill adapts the length to the presentation time.

/user:presentation-slides 15-min pitch for leadership on Q1 results

Use cases:

• Results presentations for the executive committee
• Product pitches for clients or investors
• Internal training for teams
• Conference presentations

Download this skill

LinkedIn Post

A bonus Skill for those who maintain a LinkedIn presence. Claude structures the post with an attention-grabbing hook, concise development points, and an appropriate call-to-action.

/user:linkedin-post sharing my experience on AI adoption in my 10-person team

Use cases:

• Sharing professional experience and lessons learned
• Recruitment or new project announcements
• Reactions to industry news
• Personal branding and expertise positioning

Skill taxonomy

The Claude Code team, together with Thariq Shihipar, proposed a nine-category classification to organize skills by what they actually automate. This framework helps you identify the kind of skill you need and name your own creations consistently.

1. Library & API Reference

Skills that embed the internal documentation of an API or library: gotchas, anti-patterns, conventions specific to your stack. Claude doesn't have to guess — the answer is already in its context.

Examples: stripe-api, internal-design-system, prisma-patterns

2. Product Verification

Skills that run automated checks on user flows: Playwright, tmux, smoke tests. They answer the question "is this still working?" without you having to open a browser.

Examples: verify-checkout-flow, smoke-test-auth, e2e-critical-paths

3. Data Fetching & Analysis

Skills that connect to your dashboards, databases, or analytics APIs to retrieve and interpret metrics. Useful for daily reviews or regression investigations.

Examples: fetch-metrics, query-datadog, analyze-funnel

4. Business Process & Team Automation

Skills that automate repetitive team tasks: posting the standup to Slack, creating a Jira ticket from a bug, sending a deployment notification.

Examples: standup-post, create-ticket, notify-deploy

5. Code Scaffolding & Templates

Skills that generate boilerplate code from a template defined by your team. They ensure every new file follows project conventions from the start.

Examples: new-migration, create-component, scaffold-api-endpoint

6. Code Quality & Review

Skills that analyze code against precise rules: style, complexity, security, consistency with the rest of the project. More nuanced than a linter, they factor in business context.

Examples: adversarial-review, enforce-code-style, check-complexity

7. CI/CD & Deployment

Skills that interact with your deployment pipeline: monitoring a PR, triggering a deploy, cherry-picking a fix to the production branch.

Examples: babysit-pr, deploy-staging, cherry-pick-prod

8. Runbooks

Multi-step investigation skills triggered by a symptom. They guide Claude through an ordered series of checks to identify the root cause of an incident, like an ops runbook but executed automatically.

Examples: investigate-latency-spike, diagnose-auth-failure, incident-response

9. Infrastructure Operations

Regular maintenance skills: cleaning up stale branches, updating dependencies, rotating secrets, infrastructure audits. They automate the tasks nobody wants to do but everyone has to.

Examples: cleanup-stale-branches, update-dependencies, rotate-secrets

Best practices for writing a skill

Here's what the Claude Code team has learned about writing effective skills. These rules separate a skill you use once from one you use every day.

1. Don't state the obvious

A skill should focus on what pushes Claude outside its default behavior. No need to say "be precise" or "use TypeScript if the project is in TypeScript." Only include what actually changes something.

2. The "Gotchas" section is the most important part

This is where you document the traps you discovered the hard way: the API that returns 200 even on error, the function that mutates its argument in place, the environment variable that must be set before the other one. A skill without gotchas is an incomplete skill.

3. Progressive disclosure

Don't load everything into the main file. Organize your skill into folders and put only what's needed on every call inside SKILL.md. Reference documentation goes in references/, utility scripts in scripts/, examples in examples/.

.claude/skills/my-skill/
  SKILL.md              # Main file, loaded on every call
  references/           # Reference documentation (loaded if needed)
  scripts/              # Utility scripts
  examples/             # Code examples
  config.json           # Skill configuration

4. Don't railroader Claude

Describe your objectives and constraints, not the steps to follow. If you script every step, you prevent Claude from adapting its approach to the actual context. Trust it to find the path — just point it at the destination.

5. The description field is a trigger, not a summary

A skill's description tells Claude whether to activate it automatically in a given context. It should describe the situations that call for this skill, not how it works internally.

6. Store config in a config.json

Parameters that vary from project to project (branch names, endpoints, coverage thresholds) shouldn't be hardcoded in the Markdown file. Put them in a config.json next to the skill.

7. Include scripts for Claude to compose

Rather than having Claude reconstruct the same commands on every call, provide utility scripts in scripts/. Claude will compose and call them based on context, without reinventing them each time.

8. On-demand hooks

A skill can activate or deactivate Claude hooks dynamically. For example, a deployment skill can enable a "pre-commit" hook only for the duration of the process, then disable it once done. Cleaner than a global hook that's always active.

9. One skill, one responsibility

The temptation is to build a mega-skill that does everything. Resist it. A focused skill is easier to maintain, faster to load, and more precise in its results. If your skill exceeds 200 lines, it's probably two skills.

Downloadable Skill files

All Skills presented on this page are available for direct download. Copy them into .claude/commands/ (project) or ~/.claude/commands/ (personal) and they're immediately usable.

Technical Skills

Non-technical Skills

Summary

Finding Skills that fit your needs

The Skills presented on this page are just a glimpse of what's available. The Claude ecosystem is growing fast and new creations appear every week. To help you explore all the available resources, one essential reference exists.

Next steps

You now know the most useful Skills and where to find more. Let's move on to creating your own custom Skills.

• Create a custom Skill step by step: Write your own Skills tailored to your workflow
• Skills vs MCP vs Plugins: Understand when to use each tool
• What is a Skill?: Back to fundamentals
• Top development MCPs: Combine your Skills with Context7, GitHub, and Sentry