Claude Code Hooks and Skills are the two extensibility systems built into @Claude Code — hooks for automated reactions to events, and skills for reusable prompt workflows. Together, they turn Claude Code from a general-purpose agent into a customized @augmentation system tailored to your specific workflow.

Hooks

Hooks are shell commands that execute automatically in response to Claude Code events. They're configured in ~/.claude/settings.json and fire without manual intervention.

What Triggers Hooks

• Tool calls — before or after Claude runs a tool (Read, Edit, Bash, etc.)
• Notifications — when Claude finishes a task or wants your attention
• Prompt submission — before your message is sent to Claude
• Session events — start, stop, or context changes

Examples

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "command": "npx eslint --fix $CLAUDE_FILE_PATH"
      }
    ],
    "Notification": [
      {
        "command": "osascript -e 'display notification \"$CLAUDE_NOTIFICATION\" with title \"Claude\"'"
      }
    ]
  }
}

The first hook runs ESLint after every file edit — automatic formatting without asking Claude to do it. The second sends macOS notifications when Claude finishes background work.

Practitioner Patterns

In @BrianBot's workflow, hooks handle:

• Post-commit linting — catches formatting issues before they hit CI
• Metrics logging — the session-metrics-logger plugin posts token data to the SymbioticLaw Dashboard after every session
• Notification routing — sub-agent completions route to specific Slack threads via the slack-thread-logger hook Hooks are the operational nervous system of a mature Claude Code setup. They handle the repetitive, mechanical responses so the @Collaborative Augmentation relationship stays focused on judgment and direction.

Skills

Skills are reusable slash commands — prompt workflows packaged for repeated use. Type /skillname and Claude executes a predefined sequence.

How They Work

Skills are defined in ~/.claude/skills/ as markdown files with instructions. When invoked, the skill's content is injected into the conversation as a system prompt.

Examples

• /commit — generate a commit message from staged changes, following project conventions
• /review-pr — review a pull request with specific criteria from the @CLAUDE.md
• /mythos — connect to @MythOS and load the knowledge library (see: @MythOS Claude Code Skill)

Building Custom Skills

A skill is a markdown file in ~/.claude/skills/:

---
name: deploy-check
description: Pre-deployment verification checklist
---
Run the following checks before deploying:
1. All tests pass (`npm test`)
2. No TypeScript errors (`npx tsc --noEmit`)
3. Build succeeds (`npm run build`)
4. No uncommitted changes (`git status`)
5. Current branch is staging
Report results as a checklist. If any check fails, stop and explain.

Invoke with /deploy-check. The skill loads, Claude executes the checklist, and you get a pass/fail report. Skills encode your workflow patterns so you don't re-explain them every session.

Hooks vs. Skills

• Hooks are reactive — they fire automatically when events occur. The human doesn't invoke them
• Skills are intentional — the human invokes them with a slash command when they need a specific workflow
• Hooks handle mechanics — linting, logging, notifications. Things that should happen every time without thinking
• Skills handle judgment — review, deploy-check, research. Things that need to be triggered deliberately Both contribute to the Memory layer of @The Augmentation Stack — hooks encode behavioral patterns, skills encode workflow patterns. Together they reduce the surface area of decisions the human needs to make, freeing attention for the work that actually requires judgment. Hooks were the thing that made Claude Code feel like infrastructure instead of a tool. Before hooks, I had to remember to lint, remember to log metrics, remember to check formatting. Now the system handles it. That's the augmentation pattern at the smallest scale: automate the mechanical, preserve the human for the meaningful. Skills are how I stopped repeating myself. Every project has workflows I run multiple times a week — deploy checks, PR reviews, MythOS operations. Packaging these as skills means I type a slash command instead of re-explaining the process. The skill file is just a markdown prompt, but it's a prompt I never have to write again.

Contexts

• #agentic-augmentation
• #claude-code