Skills, named invokable prompts

A skill is a reusable, named workflow you can invoke in Claude Code with a single slash command. It bundles a prompt, any tools it needs, and permission rules, and gives it a name like /review or /summarize-thread. The practical effect: every repeated task in your life becomes a one-word command instead of a prompt you rewrite every time. Think of it as your agent's command palette.

The idea in one sentence.

If you catch yourself typing the same prompt twice, it should be a skill. That's the whole principle. Anything you've figured out how to ask Claude well, any recurring workflow, any "this prompt works great for X", can be captured as a skill and invoked by name from then on.

Before skills, every time you wanted Claude to review code, you'd paste a long prompt describing exactly what kind of review you wanted. After skills, you just type /review. The prompt is still doing the work, but you've given it a label and put it somewhere Claude Code can find.

Anatomy: what's inside a skill.

A skill is a small directory with three things in it:

You can look at any of the built-in skills that ship with Claude Code to see exactly how they're structured. They're plain text files, so you can read them, copy them, and modify them.

A concrete example.

Let's build /summarize-thread: a skill that fetches a specific Slack thread and produces a three-bullet summary.

The manifest says: name is summarize-thread, it needs the Slack MCP (mcp__slack__*), and it takes one argument: a thread URL.

The prompt body says, roughly:

You're summarizing a Slack thread. Use the Slack MCP to fetch the thread
at the URL given. Produce exactly three bullets:
1. Who the participants are.
2. What was decided (if anything).
3. What the open questions are.

Keep each bullet under 20 words. No markdown formatting.
If the thread has fewer than 3 messages, say so and skip the summary.

When you (or the model) type /summarize-thread <url>, Claude Code loads the prompt, fills in the URL argument, and runs. The model does the work. You get a consistent, three-bullet summary every time.

Built-in skills worth knowing.

Claude Code ships with a bunch of skills out of the box. These are the ones you'll actually use:

• /review, review pending changes in the current repo (pairs with git status)
• /security-review, focused security audit on changed files
• /simplify, look at recent code for over-engineering, recommend cuts
• /init, generate a CLAUDE.md tailored to the current codebase
• /loop, re-run a prompt on a schedule (for ongoing work)
• /fewer-permission-prompts, analyzes your session history and suggests new allow-list entries to reduce future interruptions

Run /help in Claude Code to see the full list on your install. Read the source of a few skills to see how they're built; they're often the clearest way to learn the pattern.

Skill vs. Hook vs. MCP. When to use which.

All three are ways to extend Claude Code, and they're easy to confuse. Here's the clean split:

Short rule: if a user explicitly wants to do a thing, make it a skill. If something should happen automatically on an event, make it a hook. If you're giving the model a new capability to use freely, make it an MCP.

Writing a good skill, five rules.

1. Narrow scope. One job, done well. "Summarize a Slack thread" is a good skill. "Slack assistant" is too broad. The narrower the scope, the better the skill.
2. Clear description. The description field should say when to use the skill AND when not to. "Use when you need a 3-bullet summary of a single Slack thread. Do NOT use for multiple threads at once."
3. Deterministic output. Specify format, structure, length. If you don't say "3 bullets, each under 20 words," you'll get a different thing every run. Vague prompts produce vague results.
4. Declare your permissions. If the skill needs an MCP or specific tools, list them in the manifest. Claude Code can then pre-approve them just for this skill, instead of asking on every invocation.
5. Include a worked example in the prompt. One or two concrete examples of perfect output teaches the model much better than abstract instructions. This is few-shot prompting at the skill level.

Where skills live.

Three locations, in increasing scope:

• Personal, ~/.claude/skills/. Your own skills, available in every Claude Code session.
• Project-scoped, .claude/skills/ inside a repo. Skills that only make sense in that project. Check into git so the team gets them too.
• Bundled in a plugin, distributed together with MCPs and hooks. Good for sharing a coherent workflow with many people.

Skills as your agent's command palette.

Spend a month serious with Claude Code and you'll build up 20+ skills. Not because you planned to; because every time you type the same prompt twice, capturing it as a skill pays for itself within a week. Your command palette grows in step with your workflow.

This is the real leverage. You stop remembering how to ask Claude things well. You remember the name of the skill. The cognitive overhead of "what was that prompt that works for X again?" disappears. Over time, your entire recurring workflow is just a list of slash commands, each one carrying years of your prompt-engineering refinement with it.