In the Claude agent ecosystem, two concepts look similar on the surface but serve fundamentally different roles. Only one of them gets talked about.
Skills get all the attention — and fairly so. They're easy to grasp: write a markdown file, define a workflow, and you're done. The agent detects it as a reusable pattern. It's like teaching the agent how to do something. Clear input, clear output, shareable across teams.
Hooks are a different story.
"Skills tell the agent what it can do. Hooks tell the agent what it must — and must not — do."
The problem: nobody is talking about hooks
Hooks like PreToolUse, PostToolUse, Notification, and Stop live at the edges of execution. They don't add new capabilities. Instead, they govern agent behavior — and that distinction is everything.
| Skills | Hooks | |
|---|---|---|
| Role | The "how" | The "this far and no further" |
| Purpose | Structured instructions for solving tasks | Execution rules that apply unconditionally |
| Examples | Analyze a repo, generate an endpoint, transform a PDF | If something fails twice, STOP. Re-evaluate and report. |
| Scope | Reusable, shareable, scale across teams | Global — applies regardless of the task |
The mental model isn't intuitive. People prefer adding capabilities over constraining them. There's no "hook marketplace." Hooks don't look like features. And they require real operational experience to design — they emerge from mistakes, not theory. That's exactly why most teams skip them.
Hooks as encoded memory
Think of hooks as lessons learned converted into code. Every time an agent:
- Re-reads files unnecessarily
- Explores irrelevant code paths
- Generates bloated output with no real value
- Insists on a strategy that isn't working
...that failure is a candidate for a hook.
A real hook rule
// PreToolUse — read-once hook
if (file_already_read && !file_modified) {
block_execution()
return "validate.ts is already in context"
}
// 0 tokens consumed. 0 extra latency.
Over time, your hooks stop being patches and start being quality standards. The agent doesn't need to be reminded. It simply cannot do certain things.
The real cost: token consumption follows a power law
There's a data point that tends to get buried: a small set of bad behaviors generates the majority of cost in Claude agents. Skills don't address this. Hooks do, because they attack the behavior, not the capability.
| Metric | Impact |
|---|---|
| Cost from file re-reads | 40–60% |
| Loops without a stop hook | ∞ |
| Tokens if hook blocks the call | 0 |
Where exactly does a hook act?
To understand why hooks are powerful, you have to understand the Claude tool execution cycle. Every time the agent wants to take an action — read a file, run a command — it passes through four stages:
| Hook | Stage | Problem it solves | Why this stage |
|---|---|---|---|
PreToolUse |
Before action | Redundant reads, bad strategy | Intercepts before the cost exists |
PostToolUse |
After action | Logging, validation, output trimming | Tokens already spent — observation only |
Notification |
Global events | Alerting, monitoring | No real control, observation only |
Stop |
Termination | Infinite loops, repeated failures | Hard exit — prevents runaway agents |
"Hooks are powerful not because of what they do, but because of when they act. read-once works because it cuts the problem before it exists."
If read-once were a PostToolUse hook, the file would already be read, the tokens already spent. As a Skill, it wouldn't be global — it could be bypassed outside the defined workflow. PreToolUse is the only stage that intercepts before the cost is incurred and applies unconditionally.
The combination that actually works
The most robust Claude agent setups today don't choose between skills and hooks — they combine them deliberately, with subagents for complexity scaling.
Skills → Productivity → What gets done Hooks → Discipline → How it gets done Subagents → Scale → How far it goes
Productivity without discipline scales chaos. Skills without hooks produce capable agents that are also unpredictable, expensive, and hard to trust in production.
The teams building reliable agent systems are the ones investing in both — and in the operational experience needed to know which behaviors deserve a hook.
Conclusions.
"Maturity in an agent system isn't measured by how many skills it has. It's measured by how well it knows when to stop."
“The one who does not have a memory creates one of paper.” Gabriel García Márquez.
Thanks for your time!
Guillermo A. Del Vecchio.