10 Best Claude Code Skills for Developers in 2026

Quick answer: The best Claude Code skills in 2026 are Systematic Debugging, Test Driven Development, Writing Plans, Subagent Driven Development and Requesting Code Review.

All ten are free, open-source and MIT-licensed. Each links to its skill page and source repository.

Claude Code skills are reusable instruction folders that teach a coding agent a repeatable way of working. Each skill is a folder with a SKILL.md file, and some add scripts and references.

This list covers debugging, testing, planning, review, architecture and dependency hygiene.

The 10 best Claude Code skills at a glance

How we picked these skills

We started from the coding skills in the SkillDirectory catalog and kept the ones that fix a common daily problem. Then we ranked them on four things.

• Everyday usefulness: it helps on most projects, not one framework.
• Upkeep: recent commits and a recent update date.
• License: MIT, so you can reuse it with attribution.
• Clear process: the skill tells the agent what to do and when to stop.

Six of the ten come from one collection, Superpowers by obra, because its skills are designed to work together. We have not run every skill, so the ranking reflects published descriptions, license and upkeep, not a benchmark.

The 10 best Claude Code skills

1. Systematic Debugging

Best for: any bug, failing test or unexpected behaviour.

It makes the agent find the root cause before proposing a fix, using four phases and an iron law against guessing.

Why it ranks first: guessing at fixes is the most common way agents waste time.

Heads-up: it is slower than a quick patch, which is the point, but overkill for an obvious typo.

Details: MIT license · 7 commits in the last six months · skill page · source repository

2. Test Driven Development

Best for: building features test-first.

It enforces red-green-refactor: write a failing test, write the minimum code to pass it, then refactor.

Why it made the list: tests written first give the agent a clear definition of done.

Heads-up: strict test-first can feel heavy for throwaway prototypes.

Details: MIT license · 9 commits in the last six months · skill page · source repository

3. Writing Plans

Best for: multi-step work that needs a plan before any code.

It turns a spec into an implementation plan with a scope check, a file structure and right-sized tasks.

Why it made the list: a written plan is what makes later steps checkable.

Heads-up: planning adds time up front, so skip it for tiny changes.

Details: MIT license · 6 commits in the last six months · skill page · source repository

4. Subagent Driven Development

Best for: executing a plan with independent tasks.

It hands each task to a subagent in the current session and includes notes on model selection and a task loop.

Why it made the list: it is the most active skill here, with 47 commits in six months.

Heads-up: it needs a clear plan first, and you should check each task's output before the next begins.

Details: MIT license · skill page · source repository

5. Requesting Code Review

Best for: getting a review at the right moments.

It sets out when an agent should ask for review, after tasks, after major features and before merging, and how to ask well.

Why it made the list: it also lists the excuses that signal a review is being skipped.

Heads-up: it is a process skill, so it only helps if someone actually reviews.

Details: MIT license · 8 commits in the last six months · skill page · source repository

6. Architecture Patterns

Best for: structuring a backend that stays maintainable.

It explains Clean Architecture, Hexagonal Architecture and Domain-Driven Design.

Why it made the list: it was updated in October 2026 and applies to many stacks.

Heads-up: these patterns add structure that small projects may not need.

Details: MIT license · skill page · source repository

7. API Design Principles

Best for: designing REST and GraphQL APIs.

It covers resource design, schema design and versioning strategy, followed by best practices.

Why it made the list: API mistakes are expensive to undo once clients depend on them.

Heads-up: your own conventions should win when they conflict with its general advice.

Details: MIT license · skill page · source repository

8. Playwright Skill

Best for: checking a running app in a real browser.

It detects running dev servers and writes reusable test scripts. It also handles screenshots, responsive checks, login flows and link checking.

Why it made the list: it lets you say what to verify and get a working script back.

Heads-up: it needs Playwright and its browsers installed, and test logins should use test accounts.

Details: MIT license · 2 commits in the last six months · skill page · source repository

9. Dep Audit

Best for: keeping dependencies safe and current.

It audits outdated packages, security advisories, version conflicts and licence problems. It reads Node.js, Python, Rust and Go projects and writes a prioritised update plan.

Why it made the list: it covers several languages in one pass.

Heads-up: run your usual audit tool as well, and apply updates in small batches.

Details: MIT license · skill page · source repository

10. Using Git Worktrees

Best for: keeping agent work off your current branch.

It checks whether isolation already exists, prefers native worktree tools and falls back to git worktrees. It then sets up the project and verifies a clean baseline.

Why it made the list: isolation makes experiments safe to discard.

Heads-up: each worktree needs its own dependency install, and finished worktrees should be removed.

Details: MIT license · 4 commits in the last six months · skill page · source repository

Honorable mentions

These skills just missed the top ten.

• Debugging and Error Recovery: a stop-the-line triage checklist.
• Parallel Debugging: competing hypotheses for stubborn bugs.
• Receiving Code Review: handling review feedback with verification.
• Finishing a Development Branch: choosing how to integrate finished work.
• E2E Testing Patterns: reliable Playwright and Cypress tests.
• Code Health: dead code and tech-debt scans.

How to install a Claude Code skill

Installing a skill means placing its folder where Claude Code looks for skills.

1. Open the skill page and follow the source link.
2. Copy the skill folder into your Claude Code skills folder.
3. Start a new session and describe the task.

Full steps are in our guide on how to install an agent skill. Skills can include scripts, so read one before installing and use our safety checklist.

Which skill should you start with?

• Bugs keep coming back: Systematic Debugging.
• Features keep breaking things: Test Driven Development.
• Work gets messy over many steps: Writing Plans, then Subagent Driven Development.
• Reviews are rushed: Requesting Code Review.
• Running a web app: Playwright Skill.

Frequently asked questions

What are Claude Code skills?

Claude Code skills are instruction folders that teach a coding agent a repeatable way of working. Examples are debugging by root cause, writing tests first or asking for review.

Are Claude Code skills free?

Yes. All ten here are free and MIT-licensed, so you can reuse them with attribution.

How many skills should I install?

Start with three to five that fix problems you actually have. Skills with overlapping descriptions can compete, so add them one at a time.

Do coding agent skills work in Cursor or other agents?

Support varies by tool. Skills use an open folder format, but each agent loads them differently. Check your tool's documentation for the skills location.

Are agent skills safe to install?

Treat a skill like code from a stranger and read it first. Our safety checklist lists what to look for.

Methodology and disclosure

Data was checked on October 29, 2026 from each skill's page in the SkillDirectory catalog. Update dates and commit counts come from the source repositories.

We wrote the reviews from each skill's published description and outline, and we have not run every skill.

Browse more in our Coding category and the Testing & QA category.