Top Ready-Made Claude Code Hooks — End-to-End Product Development

Hooks are the automation and enforcement layer of Claude Code.

A useful mental model is:

Skills  → How Claude performs work
Agents  → Who/what specialized role performs work
Hooks   → What automatically happens before, after, or during work

For a production setup:

Product / Requirements
        ↓
Agents
        ↓
Skills
        ↓
Claude Code Tools
        ↓
        HOOKS
  ├── Safety
  ├── Quality Gates
  ├── Testing
  ├── Security
  ├── Git Protection
  ├── Observability
  └── Session Automation

Claude Code hooks can run around events such as PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, and others. Official hook-development guidance describes hooks as event-driven automation for validating operations, enforcing policies, loading context, and automating workflows. (GitHub)

🏆 Top Hook Repositories

Recommended repositories to investigate

Phase → What You Need → Ready-Made Hook → Repository → Priority

Phase 0 — Claude Code Foundation & Session Management

Recommended Foundation Stack

SessionStart
    ↓
Load Project Context
    ↓
Validate Environment
    ↓
Start Development
    ↓
Log Activity
    ↓
Stop / Compact
    ↓
Save Session Context

The MOlechowski/claude-hooks collection includes dedicated session-memory functionality designed to preserve context across compaction, while its observability plugin logs tool and session events. (GitHub)

Phase 1 — Product Discovery & Requirements

Hooks are less important here than agents and skills, but they can enforce workflow quality.

Recommended Hook

requirement-before-implementation

Purpose:

Before Claude writes major implementation code:

Check:
✓ Requirement exists
✓ Acceptance criteria exist
✓ Architecture decision exists where needed
✓ Task scope is clear

This is usually worth making project-specific.

Phase 2 — Architecture & Design

Recommended Hooks

architecture-guard
adr-validator
breaking-change-detector

Example flow:

Claude wants to modify:

/src
/domain
/api-contracts
/infrastructure

        ↓

PreToolUse Hook

        ↓

Check:
- Is this a breaking change?
- Does this modify public API?
- Does this modify database schema?
- Is an ADR required?

        ↓

Allow / Warn / Block

Phase 3 — Development Safety

This is one of the highest-value hook phases.

The damage-control hook blocks dangerous commands and writes to protected paths, while the hook-security plugin provides configurable blocking for risky CLI commands. (GitHub)

Phase 4 — Git & Source Control

This is a must-have hook category.

My recommended Git protection stack

PreToolUse
│
├── no-force-push
├── protected-branch-guard
├── destructive-git-command-guard
└── branch-naming

PostToolUse
│
└── commit-message-validation

The edgeless-ai collection explicitly includes protection against force pushes to main/master/production branches and branch naming enforcement. (GitHub)

Phase 5 — Security

This should be your highest-priority automation category.

The protect-secrets hook can guard sensitive files from unsafe reads, modifications, or exfiltration patterns, while the security-scan hook is designed to detect API keys and secrets before they are written to disk. (GitHub)

Recommended Security Pipeline

flowchart LR
    A[Claude Tool Call] --> B[PreToolUse]

    B --> C{Dangerous?}

    C -->|Yes| D[Block]

    C -->|No| E[Secret Scan]

    E --> F{Secrets?}

    F -->|Yes| G[Block + Warning]

    F -->|No| H[Allow]

Phase 6 — Code Quality

The verify-completion hook warns when work is declared complete without supporting test evidence, while lint-on-save runs linting after files are written. (GitHub)

Recommended Quality Flow

Write/Edit
    ↓
PostToolUse
    ↓
Lint
    ↓
Format Check
    ↓
Relevant Tests
    ↓
Stop Hook
    ↓
Verify Completion Evidence

Phase 7 — Testing & TDD

One of the most useful categories for your development workflow.

The community ecosystem includes a dedicated TDD guard intended to prevent implementation from proceeding before a failing test exists; it is best suited to projects intentionally following strict TDD. (ComputingForGeeks)

Recommended Test Pipeline

flowchart TD
    A[Edit Source File]

    A --> B[PostToolUse]

    B --> C[Run Linter]

    C --> D[Run Relevant Unit Tests]

    D --> E{Tests Pass?}

    E -->|Yes| F[Continue]

    E -->|No| G[Return Failure Context]

Phase 8 — Performance Engineering

For your stack, I recommend a custom:

dotnet-performance-check

Trigger it when changing:

Critical API
Database query
EF Core repository
Caching
Async workflow

Then optionally run:

dotnet test
BenchmarkDotNet
integration performance tests

Do not run expensive benchmarks on every file edit.

Phase 9 — .NET Development

For you, this deserves dedicated hooks.

Recommended .NET Workflow

Edit .cs File
      ↓
PostToolUse
      ↓
dotnet format
      ↓
dotnet build
      ↓
Run Relevant Tests
      ↓
Report Result to Claude

I recommend not blindly installing generic hooks for these. Create or adapt hooks around your repository structure, test projects, and build commands.

Phase 10 — Database & Schema Changes

Critical Rule

Claude wants to execute:

DROP
DELETE
TRUNCATE
ALTER

        ↓

PreToolUse

        ↓

Detect environment

        ↓

Production?
    │
 ┌──┴───┐
 │      │
YES     NO
 │      │
BLOCK   Require confirmation

This should be part of your security baseline.

Phase 11 — DevOps & Infrastructure

Recommended events:

PreToolUse
    ↓
Block dangerous infrastructure commands

PostToolUse
    ↓
terraform validate
docker build
manifest validation

Stop
    ↓
verify deployment evidence

Phase 12 — Observability & Session Intelligence

This is a very valuable category.

The observability plugin from MOlechowski/claude-hooks records tool usage, results, notifications, session events, and subagent completion. (GitHub)

Phase 13 — AI Agent Development

For your interest in AI agents and RAG, use hooks to enforce agent reliability and safety.

Agent Lifecycle

flowchart TD
    A[Agent Starts]

    A --> B[SubagentStart Hook]

    B --> C[Tool Call]

    C --> D[PreToolUse Guard]

    D --> E[Tool Executes]

    E --> F[PostToolUse Logger]

    F --> G[Agent Completes]

    G --> H[SubagentStop Validation]

Phase 14 — Completion & Release Gates

These hooks prevent Claude from declaring success too early.

The verify-completion hook is specifically intended to flag completion claims that lack evidence of test execution. (GitHub)

🏆 My Recommended Top 20 Hooks for You

Based on your .NET + architecture + AI + Claude Code focus:

🥇 My Recommended Installation Strategy

Layer 1 — Install First: Safety

From edgeless-ai/claude-code-hooks:

damage-control
no-force-push
security-scan

From karanb192/claude-code-hooks:

block-dangerous-commands
protect-secrets

Choose overlapping hooks carefully—don’t install two hooks that block the same command with conflicting rules.

Layer 2 — Quality

From edgeless-ai/claude-code-hooks:

lint-on-save
test-on-change
verify-completion

Layer 3 — Observability

From MOlechowski/claude-hooks:

hook-observability
hook-session-memory

Layer 4 — Your Custom .NET Hooks

Create:

dotnet-build-on-change
dotnet-test-on-change
dotnet-format-check
ef-migration-validator
dotnet-security-scan

Recommended .claude/hooks Structure

.claude/
│
├── settings.json
│
├── hooks/
│   │
│   ├── safety/
│   │   ├── damage-control.py
│   │   ├── no-force-push.py
│   │   ├── secret-protection.py
│   │   └── protected-paths.py
│   │
│   ├── quality/
│   │   ├── lint-on-save.py
│   │   ├── test-on-change.py
│   │   └── verify-completion.py
│   │
│   ├── dotnet/
│   │   ├── build-on-change.sh
│   │   ├── test-on-change.sh
│   │   ├── format-check.sh
│   │   └── ef-migration-check.sh
│   │
│   ├── git/
│   │   ├── branch-guard.py
│   │   └── commit-validation.py
│   │
│   ├── architecture/
│   │   └── architecture-change-guard.py
│   │
│   ├── infrastructure/
│   │   ├── terraform-guard.sh
│   │   ├── kubernetes-validator.sh
│   │   └── production-deploy-guard.sh
│   │
│   ├── observability/
│   │   ├── tool-logger.py
│   │   └── session-logger.py
│   │
│   └── agents/
│       ├── agent-tool-guard.py
│       └── subagent-validator.py

Hook configuration can live at user, project, local-project, managed-policy, plugin, and skill/agent scopes; project-level configuration can be shared in a repository. (GitHub)

Recommended End-to-End Hook Architecture

flowchart TD

    A[Claude Code Session Start]

    A --> B[SessionStart]
    B --> C[Load Context]
    C --> D[Validate Environment]

    D --> E[Claude Agent / Skill]

    E --> F[PreToolUse]

    F --> G{Safety Check}

    G -->|Blocked| H[Stop Dangerous Action]

    G -->|Allowed| I[Execute Tool]

    I --> J[PostToolUse]

    J --> K[Lint]
    J --> L[Test]
    J --> M[Log]

    K --> N[Continue]
    L --> N
    M --> N

    N --> O[Stop Hook]

    O --> P{Completion Valid?}

    P -->|No| Q[Request More Work]

    P -->|Yes| R[Session Complete]

The Most Important Rule

Do not install every hook you find.

Hooks can execute commands automatically with the same privileges available to your development environment. Treat a third-party hook like any executable script: inspect it before enabling it, especially hooks that run shell commands, modify files, access secrets, or interact with cloud infrastructure. (GitHub)

My ideal starter set for you

SAFETY
├── damage-control
├── no-force-push
└── protect-secrets

QUALITY
├── lint-on-save
├── test-on-change
└── verify-completion

OBSERVABILITY
├── hook-observability
└── hook-session-memory

.NET CUSTOM
├── dotnet-format-check
├── dotnet-build-on-change
└── dotnet-test-on-change

This gives you a strong foundation without turning every Claude Code action into a slow chain of overlapping hooks.