Hooks vs Skills in Claude: the difference that defines system maturity

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.