Claude Code hooks block rule-skipping with code

Anyone who's used Claude Code has probably noticed that Claude sometimes follows the rules written in CLAUDE.md and sometimes skips them. As the video's title puts it, hooks are the tool that turns rules Claude "usually follows" into procedures it "cannot skip."

CLAUDE.md rules carried no enforcement

As covered in Karpathy's critique of LLM coding, distilled into a single CLAUDE.md file, CLAUDE.md works by consolidating principles like "no assumptions," "minimal code," "minimal changes," and success criteria into a single file that instructs Claude Code. But because the file is ultimately just guidance Claude refers to, there was always room for Claude to miss or work around the rules depending on the situation. This fifth lesson covers how to close that gap using hooks.

Put simply, CLAUDE.md is a file where developers write down the rules Claude Code should follow, but whether Claude actually followed them varied case by case. Hooks pin down the parts of those rules that must never be broken, using code that automatically blocks or corrects Claude the moment it tries to violate them.

What hooks are

A hook is deterministic code that runs at set points in Claude Code's execution loop. Because it's deterministic, it behaves the same way under the same conditions every time, which means it can enforce set rules even when no one is watching the run.

Seven commonly used events

Event	Trigger point	Typical use
pre_tool_use	Right before a tool call	Allow, deny, or confirm risky commands
post_tool_use	Right after a tool call succeeds	Auto-formatting, linting
stop	When Claude tries to end a task	Reject termination if conditions aren't met
subagent_stop	When a subagent terminates	Applies the same signal as stop to subagents
pre_compact / post_compact	Before and after compaction	Check the compaction process
instructions_loaded	When rule files like CLAUDE.md load	Audit what actually made it into context
session_start	At session start	Prepare the environment, reinject context after compaction

The video specifically noted that if you want to reinject context after compaction, you should use session_start with a compact matcher rather than post_compact.

Exit codes that decide the outcome

Code	Meaning	Note
0	Success	If stdout is JSON it's parsed; plain text is mostly ignored, but for session_start, user_prompt_submit, and user_prompt_expansion it's added to context
1	Looks like an error but doesn't block	Claude executes the command as-is
2	Blocking error	Stderr is passed to Claude as context and acts as the blocking code for nearly every event (the exception is worktree_create, where any non-zero code aborts)

A pre_tool_use hook returns JSON with one of allow, deny, or ask in the permission decision field. There's a fourth value, defer, but it's only used in the special case of a non-interactive -p run where the calling process pauses the tool and resumes it later.

Two practical examples

For masking secrets, a pre_tool_use hook can specify the bash tool as the matcher, narrow it down to a specific command with an if clause, and return updated_input instead of deny. That lets execution continue with just the password portion stripped out, without blocking the command entirely. But because updated_input replaces the whole input object, you have to return the unchanged fields as well, exactly as they were.

When a conversation runs long and Claude performs compaction, a lot of detail gets lost. A session_start hook with a compact matcher runs immediately after compaction and puts a short summary of the files being worked on back into context. That summary lets Claude pick up where it left off instead of starting over from before the compaction.

Editor's take

If auto mode was the change that let Claude move without approval at every step, hooks are the counterpart that keeps that expanded autonomy from ever touching certain rules. Anthropic is essentially refining Claude Code to move fast while drawing the lines it must not cross with code, rather than with human oversight.

It wasn't long ago that consolidating rules into a single CLAUDE.md file became a trend, and now there's a mechanism that pushes those rules from "nice to follow" up to "must be followed." Teams that already have a CLAUDE.md rules file can feel the difference right away just by adding a single pre_tool_use hook, catching risky commands before they run.

A common complaint among Korean development teams adopting Claude Code is that it "sometimes skips the rules," and this lesson points to the answer: start with just the pre_tool_use and stop events. Rather than trying to use all thirty-odd events at once, setting up just three — pre_tool_use to block dangerous commands, stop to check task-completion conditions, and session_start to restore context after compaction — can meaningfully cut down on real incidents.