Git hooks are executable programs that Git runs at named points in repository operations. Use them to automate quick local checks and notifications; put rules that everyone must follow in server-side hooks or CI, because developers can bypass local checks.
Choose a hook by when the work should happen
A hook is tied to a Git event, so choose the event that gives the right feedback without pretending a local check is mandatory policy. Git passes hooks information through arguments, environment variables, or standard input, depending on the hook.
As an Amazon Associate I earn from qualifying purchases.
| Event | When it runs | What it is suited to | Can it stop the operation? |
|---|---|---|---|
pre-commit |
Before Git obtains the proposed commit message and creates the commit | Quick checks on staged changes | Yes. A nonzero exit status aborts the commit; --no-verify bypasses it. Git hook reference |
commit-msg |
While Git is processing the proposed commit message | Inspecting or editing the message, such as enforcing a format | Yes. A nonzero exit status aborts the commit; --no-verify bypasses it. Git hook reference |
post-commit |
After a successful commit | Notifications or other follow-up actions | No. It runs after the commit has succeeded. Git hook reference |
pre-push |
Before a push is sent | Checks that need destination and ref information | Yes. It can stop the push. Git hook reference |
pre-receive |
On the receiving server, once for a receive operation | Shared rules for proposed ref updates | Yes. It can reject the proposed updates. Git hook reference |
Run a check before each commit
Put a fast check in pre-commit when it should give feedback before a commit is created. Make the check clear about what failed and how to fix it. Keep in mind that git commit --no-verify skips this hook.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallValidate commit messages
Use commit-msg when a rule concerns the proposed message. Git gives this hook the message-file path; the hook can inspect or edit that file. A nonzero exit rejects the commit, but --no-verify can bypass the check.
#1 Best Overall
Run something after a commit or before a push
Choose post-commit for a notification that should follow a successful commit, not for a check that must prevent one. Use pre-push for a check that should run before sending refs to a remote. The Git hook reference describes the event context and information available to these hooks.
Install hooks where Git will find them
Git normally looks for hook programs in $GIT_DIR/hooks. The core.hooksPath setting can point Git to a different directory. A hook file must be executable or Git ignores it. Hook files are not ordinarily distributed as part of a repository’s committed working-tree files, so a clone should not be assumed to arrive with a team’s custom hooks installed.
Rank #2
-
Check the repository’s Git directory and configured hook path. Git’s reference for hooks and
core.hooksPathexplains the defaults and override.Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy. -
Place the hook program in the active hooks directory, using the exact event name such as
pre-commit. -
Make it executable using the permissions mechanism for your platform. Git ignores hook files without the executable bit.
-
Test it with the repository’s actual interpreter and path assumptions, including the way it receives staged files or message input.
-
Give contributors a documented setup route and a clear explanation of what each hook checks and how to resolve a failure.
Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.
Git may copy example hooks during git init depending on configuration, but that is not the same as automatically installing a project’s custom hooks for every clone.
Best Value
Make hook behavior reliable across repositories
Git changes the working directory before invoking hooks. Server-side receive hooks run in the bare repository’s Git directory. A script that relies on a particular current directory can therefore behave differently across local and server contexts. Use deliberate paths, and be especially careful if a hook invokes Git commands against another repository, since environment and repository context can affect which repository those commands address.
- Keep checks focused: reserve pre-commit checks for work that benefits from immediate feedback and can finish quickly.
- Make failures actionable: report the failed check and a practical remedy rather than only returning an error code.
- Check portability: verify interpreter availability, executable permissions, file paths, and platform assumptions for contributors who need to run the hook.
- Consider interactions: if multiple checks run for one event, ensure they are safe to run together before enabling parallel execution.
Git’s current git hook documentation describes named hook commands configured for events such as pre-commit and commit-msg. A command can be associated with more than one event, and multiple checks can be configured for the same event. Check git --version and the documentation for that version before relying on this configuration interface; the available behavior depends on the Git version installed.
Use local hooks for feedback, not required enforcement
Local hooks are useful reminders and early warnings, but they are not a reliable boundary for team policy. Git’s FAQ says: “The only safe place to make these changes is on the remote repository (i.e., the Git server), usually in the pre-receive hook or in a continuous integration (CI) system.” Git FAQ
Local pre-commit and commit-msg checks can be skipped with --no-verify and bypassed in other ways. They can also interfere with workflows that intentionally use temporary or fixup commits. For a rule that must apply to everyone, validate proposed changes on the server—often in pre-receive—or in CI. Local hooks can still make that process more convenient by catching problems sooner.
| Approach | When it runs | Can block? | Can a contributor bypass it? | How setup reaches contributors |
|---|---|---|---|---|
| Local client hook | At a local event such as commit or push | Yes for blocking hooks, but not for post-commit | Yes; local checks are not reliable policy enforcement | Provide a setup process; Git does not ordinarily include project hook files in a clone |
| Server-side receive hook | When a remote repository receives a push | Yes; pre-receive can reject proposed ref updates |
Not by bypassing the contributor’s local hook settings | Repository administrators configure it on the receiving server |
| CI check | When the project’s CI system evaluates the submitted changes | It can be made a required check according to the project’s CI setup | Not by skipping a local hook; enforcement depends on the project’s server-side protections | Configure and maintain it in the project’s CI workflow |
Check version-specific documentation
The online Git references change over time, and not every installed Git version necessarily supports the same configuration features. Run git --version, then consult the relevant hook reference and git hook documentation for that version.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
