Git Hooks are scripts that Git automatically executes before or after certain events, allowing you to automate parts of your development workflow. They can help enforce code standards, run tests, and perform a variety of tasks to make your development process smoother and more reliable.
1. What Are Git Hooks?
Git Hooks are scripts stored in the .git/hooks/
directory of your repository.

There are two main types of hooks:
- Client-side hooks: Triggered by actions like committing or merging.
- Server-side hooks: Used for enforcing policies before code is pushed to the remote repository.
By using Git Hooks, you can automatically run tasks like linting code, checking for commit message formatting, or ensuring that tests pass before allowing a commit or push.
2. Common Use Cases for Git Hooks
A. Pre-Commit Hooks
A pre-commit
hook runs before a commit is created. This is often used for:
- Code formatting: Automatically format code using tools like Prettier or ESLint.
- Linting: Ensure that your code follows predefined standards before it’s committed.
- Running tests: Ensure that unit tests pass before allowing a commit.
Example of a pre-commit
hook to check code formatting:
#!/bin/sh
eslint . --fix
B. Pre-Push Hooks
A pre-push
hook runs before changes are pushed to the remote repository. It can:
- Ensure that all tests pass before allowing a push.
- Check for conflicts in the remote branch.
Example of a pre-push
hook to run tests:
#!/bin/sh
npm test
C. Post-Checkout Hook
A post-checkout
hook runs after checking out a branch. This can be useful for:
- Setting up the environment: Automatically installing dependencies or setting up configuration files.
Example:
#!/bin/sh
npm install
D. Commit-Message Hook
A commit-msg
hook ensures that commit messages follow a specific format, such as enforcing a convention for issue numbers or making messages descriptive.
Example of enforcing a commit message format:
#!/bin/sh
if ! grep -qE "^(feat|fix|docs|style|refactor|test|chore):" "$1"; then
echo "Commit message does not follow convention" >&2
exit 1
fi
3. How to Set Up Git Hooks
To set up a Git Hook:
- Navigate to the
.git/hooks/
directory in your repository. - Find the hook you want to modify (e.g.,
pre-commit.sample
). - Rename the file (e.g.,
pre-commit
) and write your script inside it.
Make the hook executable:
chmod +x .git/hooks/pre-commit
You can also manage hooks using tools like Husky, which simplifies the process and works across teams.
4. Client-Side vs. Server-Side Hooks
Client-Side Hooks
Client-side hooks run locally on your machine and include hooks like pre-commit
, pre-push
, and post-checkout
. They are useful for maintaining quality before code is shared with the team.
Server-Side Hooks
Server-side hooks run on the remote server and are used for enforcing project-wide policies, like requiring tests to pass before code is merged.
5. Best Practices for Using Git Hooks
A. Keep Hooks Lightweight
Don’t overload hooks with time-consuming tasks that could slow down development. Instead, use hooks for critical checks, like linting or basic tests.
B. Use Shared Hooks for Consistency
Ensure all developers on the team use the same hooks by storing them in the repository or using tools like Husky to manage them.
C. Automate Repetitive Tasks
Leverage Git Hooks to automate mundane tasks, such as running code formatters or sending notifications after a successful push.
6. Conclusion
Git Hooks are a powerful way to automate your workflow and enforce consistent practices across your team. By incorporating hooks for linting, testing, and commit message formatting, you can significantly improve your team’s efficiency and code quality.