What are Git hooks and how are they used?

Question

Accepted Answer

**Git hooks** are scripts that Git runs **automatically** at certain points in the Git workflow (before/after commits, pushes, merges, etc.). They enable automation — enforcing standards, running checks, and triggering actions — and are widely used for code quality and CI integration.

## What hooks are

```text
Hooks are executable scripts in .git/hooks/ (or managed by tools) that Git runs on EVENTS:
  CLIENT-SIDE (local):
    pre-commit   → before a commit is created (lint, format, run quick tests)
    commit-msg   → validate/format the commit message
    pre-push     → before pushing (run tests, prevent pushing broken code)
    post-merge/checkout → after merge/checkout (e.g. reinstall dependencies)
  SERVER-SIDE (on the remote):
    pre-receive / update → enforce policies on push (reject bad pushes)
    post-receive → trigger deployment/CI/notifications after a push
```

## Common uses

```text
✓ pre-commit → LINT and FORMAT code; run quick tests; block secrets/debug code
  → catch issues BEFORE they're committed (fast feedback, consistent quality)
✓ commit-msg → enforce message format (e.g. Conventional Commits)
✓ pre-push → run the test suite → don't push failing code
✓ server-side → enforce policies; trigger CI/CD and deployments
```

## Managing hooks in a team

```text
⚠️ .git/hooks/ is LOCAL and NOT committed → hooks aren't shared automatically.
To share hooks across a team, use tools:
  → HUSKY (JS ecosystem), pre-commit (Python framework), lefthook, etc.
  → these version hooks in the repo and install them for everyone
→ Combined with CI: hooks give FAST LOCAL feedback; CI is the enforced safety net
  (hooks can be bypassed with --no-verify, so CI must also enforce).
```

## Why it matters

Understanding Git hooks is valuable senior-level knowledge for **automating quality checks and workflow actions**, so it's useful for maintaining code quality and integrating with CI/CD.

Hooks enable **automation at key Git events** — running scripts automatically before/after commits, pushes, merges, etc. — which is widely used to enforce standards and catch issues early.

The most common and valuable use is the **pre-commit hook** for running **linting, formatting, quick tests, and secret-detection before code is committed** — providing fast feedback and ensuring consistent quality automatically (so problems are caught at commit time rather than later in CI or review), a hugely popular practice.

Other uses (commit-msg hooks enforcing message conventions like Conventional Commits, pre-push hooks running tests to prevent pushing broken code, and server-side hooks enforcing policies or triggering CI/CD and deployments) extend automation across the workflow.

Understanding the practical **team management** aspect is important: `.git/hooks/` is local and **not committed**, so hooks aren't shared automatically — sharing them across a team requires tools like **Husky, pre-commit, or lefthook** that version hooks in the repo and install them for everyone.

Crucially, understanding that hooks **can be bypassed** (`--no-verify`) means they provide fast *local* feedback but **CI must also enforce** the checks as the real safety net — a key insight about defense in depth (local hooks for speed, CI for enforcement).

Since automating quality checks and workflow actions improves code quality and consistency, and since Git hooks (especially pre-commit for local checks, managed via tools and complemented by CI) are a widely-used mechanism for this, understanding Git hooks — what they are, common uses, team management with tools, and their relationship to CI — is valuable senior-level knowledge for building automated, quality-focused development workflows, reflecting the practices used to maintain quality in professional teams.