Introduction

If you want one post-commit hook to apply across all repositories, the cleanest modern approach is to use Git's global hooks path. That avoids copying the hook into every .git/hooks directory manually. For future repositories, you can also use an init template, but core.hooksPath is usually the simpler global solution because it affects current repositories too.

How Git Normally Finds Hooks

By default, each repository has its own local hooks directory:

• '.git/hooks/'

That is why copying a post-commit script into one repository does not affect any others. Git treats hooks as repository-local unless you override the path.

Best Global Approach: core.hooksPath

Set a global hooks directory once:

1mkdir -p ~/.githooks
2cat > ~/.githooks/post-commit <<'HOOK'
3#!/bin/sh
4echo "post-commit hook ran"
5HOOK
6chmod +x ~/.githooks/post-commit
7
8git config --global core.hooksPath ~/.githooks

After that, Git will use ~/.githooks as the hooks directory for repositories that do not override the setting locally.

This is the most practical answer when you want the hook to affect both current and future repositories.

Why This Is Better Than Copying Files by Hand

Manual copying has several drawbacks:

• existing repositories can drift out of sync
• updates require touching many directories again
• newly created repositories still need extra setup

A global hooks path gives you one source of truth. Change the script once, and every repository using that global configuration sees the update.

Alternative for Future Repositories: Init Templates

If you specifically want new repositories to be created with hook files already present, Git templates are another option.

1mkdir -p ~/.git-template/hooks
2cat > ~/.git-template/hooks/post-commit <<'HOOK'
3#!/bin/sh
4echo "post-commit hook ran"
5HOOK
6chmod +x ~/.git-template/hooks/post-commit
7
8git config --global init.templatedir ~/.git-template

Now git init will copy that hook into future repositories created on your machine.

The key limitation is that this does not retroactively update existing repositories. That is why core.hooksPath is usually the better answer for "current and future repositories."

Existing Repositories and Overrides

Once core.hooksPath is set globally, existing repositories will use it unless they define their own local core.hooksPath value.

You can inspect the effective value with:

git config --show-origin --get core.hooksPath

That helps explain why a repository may not be using the global hook you expected.

Keep the Hook Portable

A global hook should be conservative. It may run in repositories with different languages, tooling, and layouts.

Good practices:

• use POSIX shell unless you have a strong reason not to
• avoid assumptions about the current repository structure
• exit cleanly when the hook does not apply
• keep the hook fast so every commit does not become annoying

A global hook that breaks commits in unrelated repositories is worse than no global hook at all.

Common Pitfalls

The biggest mistake is copying the hook into one repository and expecting Git to apply it globally.

Another mistake is using init.templatedir alone when the requirement includes already-existing repositories.

A third issue is writing a global hook that assumes every repository has the same tools or directory layout.

Summary

• The cleanest way to apply a post-commit hook to current and future repositories is git config --global core.hooksPath ...
• A shared hooks directory is easier to maintain than copying scripts into each .git/hooks folder
• 'init.templatedir is useful for future repositories, but it does not retroactively update existing ones'
• Repositories with local hook-path overrides may ignore the global setting
• Keep global hooks portable, fast, and conservative so they do not break unrelated repositories