Skills are to CLAUDE.md what apps are to an operating system — focused, reusable capabilities that extend what Claude can do out of the box.
Claude Skills are instruction packages you install into Claude Code to handle specific, recurring workflows without having to re-explain them every session.
A skill is a combination of:
Think of skills as plugins for your CLAUDE.md. Where CLAUDE.md tells Claude who you are and how you work generally, a skill tells Claude how to do a specific thing well — code review, writing commit messages, debugging database errors, preparing for a founder meeting.
CLAUDE.md is personal and project-level. It encodes your identity, your communication style, your hard rules, and your project conventions. One file, covers everything.
Skills are task-specific and composable. A single skill handles one workflow. You can install multiple skills and they coexist without conflict.
| CLAUDE.md | Skills | |
|---|---|---|
| Scope | Identity, project, communication | Specific recurring task |
| Count | One per project | Many — install what you need |
| Change frequency | Updates as project evolves | Stable once installed |
| Granularity | Broad and foundational | Narrow and focused |
A solid CLAUDE.md sets the foundation. Skills build on it for specific work types.
Skills install via the /plugin command in Claude Code:
/plugin install code-review@anthropic
/plugin install bug-fixing@anthropic
/plugin list
The format is name@publisher. The command downloads the skill definition and makes it available in your Claude Code session.
Once installed, you invoke a skill by referencing it in your request:
"Use the code-review skill to review this PR"
Claude reads the skill's instructions and applies them to the task. The skill becomes part of the active context for that conversation — not a permanent overlay, but a contextual capability you can invoke when needed.
A skill definition is a structured document with specific sections:
Name and description — what the skill does and when to use it.
Trigger conditions — when the skill should activate. Some skills activate automatically based on context; others require an explicit invocation.
Context and conventions — domain-specific rules, tool usage patterns, quality standards.
Output format — how results should be structured. A code review skill produces structured feedback. A commit-message skill produces conventional commits. A debug skill produces a hypothesis and a test plan.
Here's what a simplified skill structure looks like:
# Skill: Code Review
## When to use
- User asks to review a PR or diff
- User shares a file and asks for feedback
## Pre-review checks
1. Read the full diff, not just the changed lines
2. Check for logic errors before style issues
3. Identify the most likely failure modes for this change
## Output format
- **Summary**: one paragraph on what the change does
- **Concerns**: numbered list of specific issues (not "could be cleaner")
- **Recommendations**: actionable items with clear rationale
## What to flag
- Logic errors or off-by-one mistakes
- Missing error handling in new code paths
- Inconsistencies with existing conventions in the file
- Security implications of data handling changes
Code review — reviews diffs and PRs with structured feedback. Flags logic errors, convention violations, and missing edge cases. Doesn't nitpick style in code that already follows conventions.
Bug fixing — structured debugging methodology. Reproduces the issue first, forms a hypothesis, tests it, and confirms the fix before moving on.
Commit messages — generates conventional commits based on the diff. Respects the project's commit style conventions, keeps messages focused and informative.
Test writing — adds tests for new code paths. Focuses on the test cases most likely to catch regressions, not 100% coverage theater.
Documentation — writes or updates docs in the project's style. Matches existing doc patterns, includes relevant examples, flags gaps in existing coverage.
Database migrations — generates migration files following project conventions. Shows the full SQL before running it, confirms it matches the intended schema change.
Meeting prep — prepares for a specific meeting type (founder call, investor pitch, job interview) by reviewing context and generating specific materials.
The skill system is open — you can build and install your own skills for workflows specific to your work.
To create a skill:
The best skills cover tasks you do repeatedly but get wrong when you have to re-explain the context every time. If you've written "same conventions as before" in a conversation more than three times, that's a candidate for a skill.
If you're doing something once, explain it in the conversation. No skill needed.
If you're doing something repeatedly and always with the same context and output format, write a skill.
If something applies to every task in your project — your communication style, your hard rules, your stack conventions — that belongs in CLAUDE.md, not a skill.
A good test: if you'd start a conversation with "as per the code-review skill..." then it's a skill. If you'd start with "in this project we always..." then it's CLAUDE.md territory.
If you want a ready-made system of skills for a specific role — not just one skill, but a complete workflow package with a tailored CLAUDE.md, pre-configured skills, and scheduled recurring tasks — CoworKit's Starter Kits bundle everything you need:
Each kit installs as a single .plugin file that sets up your CLAUDE.md and all associated skills in under two minutes.
What's the difference between Claude Skills and Claude Code plugins?
Skills are instruction packages — the content and conventions that shape how Claude handles a specific task. Plugins (or MCP servers) are tool integrations that extend what Claude can do — connecting to external systems, running code in specific environments, accessing data sources. Skills tell Claude how to work; plugins give Claude capabilities to work with.
How many skills can I install?
There's no hard limit. Each skill adds to Claude's instruction context, so very large numbers of skills could compete for the instruction budget. In practice, 5–10 skills covering distinct workflows is a reasonable working set. If you find yourself with 20+ skills, you probably have overlap — consolidate or scope them.
Do skills persist between sessions?
Skills installed via /plugin install persist across sessions — they're part of your Claude Code configuration, not session-specific context. However, a skill's activation is conversation-scoped — you invoke it within a conversation, and its context is part of that conversation's window.
Can I share my skills with my team?
Yes. Skills are just structured markdown files. You can export them, share them, and install them on any Claude Code instance. CoworKit's Starter Kits are pre-built skill bundles designed for this — download, install, and the whole system is configured.
What's the difference between a skill and a CLAUDE.md section?
A CLAUDE.md section (like "## What I Use You For") encodes general recurring tasks in natural prose. A skill is structured: trigger conditions, output format, conventions — designed to produce consistent, specific results for one task type. Use a skill when you want consistent, formatted output. Use a CLAUDE.md section when the task is general enough that flexibility within your communication style is better than rigid structure.
Do skills override CLAUDE.md rules?
Skills are additive, not overriding. A skill adds instructions for a specific task type. Your CLAUDE.md rules still apply — the skill operates within the constraints your CLAUDE.md defines. If a skill's instructions conflict with a hard rule in your CLAUDE.md, the CLAUDE.md rule takes precedence.
Building skills one at a time works. But if you want a complete, tested system — a CLAUDE.md plus the right skills plus recurring tasks scheduled for your workflow — explore the Starter Kits. Each one is built for a specific role and installs in under two minutes.
Practical guides and prompt patterns — no fluff, unsubscribe any time.