Best Free Claude Code Skills and How to Write Your Own

Claude Code skills are folders with a SKILL.md file that teach the agent a repeatable procedure: how to deploy your app, review a pull request, or fill in a PDF form. The best free skills today come from Anthropic’s official repository and a handful of well-maintained community collections. Most teams, though, get the most value from the small skills they write for their own codebase. This guide covers both.

What a Claude Code skill actually is

A skill is a directory with a SKILL.md file inside. The file has YAML frontmatter (at minimum a name and a description) and a Markdown body with instructions. It can also bundle scripts, reference documents and templates next to it:

release-notes/
├── SKILL.md          # metadata + instructions
├── scripts/          # optional helper scripts
├── references/       # optional longer docs, loaded on demand
└── assets/           # optional templates

Anthropic developed the format and released it as an open standard, Agent Skills. As of September 2026 the client showcase lists many other agents that read the same format, including OpenAI Codex, Gemini CLI, GitHub Copilot, VS Code, Cursor and OpenCode. A skill you write for Claude Code is therefore not locked to one vendor.

Why skills instead of a long CLAUDE.md?

Skills use progressive disclosure. At startup the agent loads only each skill’s name and description, a few dozen tokens each. The full SKILL.md body is read only when a task matches the description, and bundled files are opened only when the instructions point to them. You can keep dozens of skills installed without filling the context window. Instructions in CLAUDE.md, by contrast, are loaded into every session.

A good rule of thumb:

• CLAUDE.md: short facts that apply to almost every task (build command, code style, where tests live).
• Skills: procedures and reference material that apply only sometimes (release process, database migration checklist, brand guidelines).
• MCP servers: live connections to external systems (issue tracker, database, browser). See our MCP servers guide.

Where Claude Code skills live

According to the Claude Code skills documentation, the folder location decides where a skill is available:

Scope	Path	Use it for
Personal	~/.claude/skills/<name>/SKILL.md	Your own habits across all projects
Project	.claude/skills/<name>/SKILL.md	Team procedures, committed to the repo
Nested (monorepo)	<subdir>/.claude/skills/<name>/SKILL.md	Skills that only apply inside one package
Plugin	<plugin>/skills/<name>/SKILL.md	Skills installed from a marketplace, namespaced as /plugin:skill

Skills run in two ways. You can type /skill-name yourself, or Claude can load a skill automatically when your request matches its description. Two frontmatter fields control this. disable-model-invocation: true makes a skill manual-only, which is useful for anything with side effects such as a deploy. user-invocable: false hides it from the slash menu so that only Claude can use it, which suits background reference material.

The best free Claude Code skills (as of September 2026)

We recommend a small, trusted set over installing everything you find. Skills are instructions and often scripts, so treat them like any other dependency you run on your machine.

Anthropic’s official skills repository

anthropics/skills is the reference collection. You can add it as a plugin marketplace from inside Claude Code:

/plugin marketplace add anthropics/skills
/plugin install example-skills@anthropic-agent-skills
/plugin install document-skills@anthropic-agent-skills

The skills we find most useful for development work:

• skill-creator: interactively helps you write and refine new skills. This is the best starting point for your own.
• mcp-builder: guidance for building a Model Context Protocol server.
• webapp-testing: testing local web apps with Playwright.
• frontend-design: pushes generated UIs away from generic defaults.
• claude-api: reference material for building on the Claude API.
• docx, pdf, pptx, xlsx: creating and editing office documents. Note that these four are source-available, not open source. Most other skills in the repo are Apache 2.0.

Superpowers (community)

obra/superpowers (MIT licence) is a full development methodology packaged as composable skills. It includes brainstorming, writing-plans, executing-plans, test-driven-development, systematic-debugging, verification-before-completion, requesting-code-review and using-git-worktrees. It installs with /plugin install superpowers@claude-plugins-official. Superpowers is opinionated. It works well if you want the agent to plan before coding and test before claiming it is done, and it can feel heavy for quick one-off edits.

Curated lists

Community “awesome” lists such as travisvn/awesome-claude-skills are useful for discovery. Quality varies a lot between entries, so read a skill’s SKILL.md and any scripts before you install it.

Framework-specific skills

Some framework maintainers now ship skills for their own stack. For example, Laravel Boost provides guidelines and agent skills for Laravel projects. If you work mainly in one framework, check whether its maintainers publish official skills before you write your own.

How to write your own skill

The skills that pay off most are usually project-specific: “how we cut a release”, “how we add an API endpoint”, “how we write a database migration”. Nobody else can write those for you.

1. Start from a repeated conversation

Claude Code’s documentation gives a good trigger: create a skill when you keep pasting the same instructions, checklist or multi-step procedure into chat. Do the task once with the agent, note where you had to correct it, and write those corrections down.

2. Get the frontmatter right

The Agent Skills specification requires two fields:

• name: up to 64 characters, lowercase letters, numbers and hyphens only, matching the folder name.
• description: up to 1,024 characters. It should say what the skill does and when to use it.

The description is the only thing the agent sees before it decides to load the skill, so it carries most of the weight. Compare:

# Weak: too vague to trigger reliably
description: Helps with releases.

# Strong: says what it does, when to use it, and uses the words people actually type
description: Prepares a production release. Bumps the version, updates CHANGELOG.md from merged PRs, tags the commit and drafts release notes. Use when the user asks to release, ship, cut a version or publish a new tag.

3. Write the body as instructions, not an essay

---
name: release
description: Prepares a production release ... (as above)
disable-model-invocation: true
---

## Steps
1. Confirm the working tree is clean and on `main`.
2. Run `npm test`. Stop and report if anything fails.
3. Determine the next version from commit prefixes (feat = minor, fix = patch).
4. Update `CHANGELOG.md` using the format in [references/changelog-format.md](references/changelog-format.md).
5. Show the diff and wait for approval before tagging.

## Never
- Push tags without explicit approval.
- Edit files under `migrations/`.

Some practical rules:

• Keep SKILL.md under about 500 lines. Both the Claude Code docs and the specification recommend this. Move long references into separate files and link to them one level deep.
• State what to do, briefly. Every line costs tokens each time the skill runs.
• Include a verification step. “Run the tests and show the output” beats “make sure it works”.
• Add explicit stop points before anything irreversible.
• Put deterministic work in scripts. If a step is really python scripts/bump_version.py, ship the script rather than describing the algorithm in prose.

4. Use Claude Code extras carefully

Claude Code supports more fields than the base specification, including allowed-tools (pre-approve specific tools), context: fork (run the skill in an isolated subagent), paths (only auto-trigger when matching files are involved) and shell injection with !`command` to add live output such as git diff to the prompt. These are powerful. They are also Claude Code-specific, so a skill that depends on them will not carry over to other agents unchanged.

5. Test the trigger, not just the output

Write down five or six prompts that should trigger the skill and two or three that should not. Run them in a fresh session. If the skill fires on the wrong requests, or stays quiet on the right ones, change the description before touching the body. For a structured way to do this, see our LLM evaluation guide.

Security checklist for third-party skills

• Read SKILL.md and every script before installing.
• Be wary of skills that pre-approve broad tools through allowed-tools, such as unrestricted shell access.
• Prefer skills from sources you can identify: official vendor repositories or maintainers with a track record.
• Pin to a commit or version for team use, and review diffs when you update.
• Never put secrets in a skill folder, especially in project skills that get committed.

Key takeaways

• A skill is a folder with SKILL.md: name and description in the frontmatter, instructions in the body, optional scripts and references alongside.
• The description decides whether the skill triggers. Write it with the words users actually type.
• Start with Anthropic’s official skills (especially skill-creator), add a community methodology such as Superpowers if it suits your workflow, and write project skills for your own recurring procedures.
• Keep skills short, add verification and stop points, and review third-party skills like code.

Skills are one of the cheapest ways to make an AI coding agent follow your team’s way of working. If you want help designing agent workflows, skills or integrations around your codebase, see our LLM integration service or get in touch.