Prompt, skill, hook, or MCP server?
Match the mechanism to the need: one-off gets a prompt, repeatable judgment gets a skill, must-always-happen gets a hook, external access gets MCP.
Most teams pick between prompt, skill, hook, and MCP server by habit rather than fit. Each one answers a different question, and picking the wrong one either wastes setup effort or leaves a gap the agent quietly walks around.
Prompt: one-off, no repetition expected
If you will genuinely only ask for this once — a one-time data migration script, a specific bug you'll never see again — a plain prompt is correct. Building a skill for something you'll never reuse is pure overhead: you pay the cost of writing a clear description and instructions for a task that never gets a second run.
Skill: repeatable judgment
A skill fits when the task recurs and requires judgment the agent applies differently each time — reviewing an endpoint, writing a release note, explaining a test failure. The skill packages the checklist or procedure; the agent still decides how to apply it to the specific diff or log in front of it. As covered in the anatomy of a SKILL.md, this is instructions loaded on demand, not a rule enforced by code.
Hook: must always happen, no exceptions
A hook is for the case where "the agent should remember to do this" isn't good enough — you need it to happen deterministically, every time, whether or not the agent thinks to. A PostToolUse hook that runs your test suite after every file edit doesn't rely on the agent choosing to test; Claude Code runs the hook's command regardless. If skipping the step even once would be a real problem — running lint before commit, blocking edits to a locked directory — that's a hook, not a skill, because a skill is still advisory: the agent can decide it's not needed this time.
MCP server: external data or actions
When the task needs something outside the filesystem and shell the agent already has — querying your production database, calling an internal API, reading from a ticketing system — that's what MCP (Model Context Protocol) servers expose. A skill can describe how to interpret data; only an MCP server (or an API credential handed to a shell command) can actually reach outside the sandbox to fetch it. If the task is "check the schema of the orders table," a skill can't do that on its own — it needs a tool that can query the database.
Comparing the four
| Mechanism | Who enforces it | Reused across sessions | Reaches outside the sandbox |
|---|---|---|---|
| Prompt | You, each time | No | Only what tools already allow |
| Skill | The agent, if it decides to | Yes, once saved | No, on its own |
| Hook | Claude Code, deterministically | Yes | Only what the hook's command does |
| MCP server | The server, on request | Yes | Yes, by design |
Reading the table left to right is also reading it in order of setup cost: a prompt costs nothing to write and nothing to maintain, while an MCP server is a small service you now own, with its own auth and error handling. Don't reach for the expensive option before confirming the cheap one actually falls short.
Try it today
- List the last five things you asked an agent to do more than once.
- For each, ask: does it need external data/actions (MCP), must it never be skipped (hook), or is it a judgment call (skill)?
- Convert the judgment-call items into skills first — they're the cheapest to build.
- For anything you marked "must never be skipped," check whether a hook already covers it before writing more prompt text about it.
- Leave genuinely one-off tasks as prompts — don't skill-ify everything.
Where this breaks
The categories overlap in practice: a skill can call a script that hits an API, blurring the skill/MCP line, and a hook can be too blunt for a check that has legitimate exceptions. When in doubt, start with a skill — it's the cheapest to build and easiest to delete — and promote it to a hook only once you've seen it get skipped when it shouldn't have been.
Next: five skills every backend team should have by Friday.