Touch Grass Git Hook: Do Pushes Wait for Nature?

No, a “touch grass” git hook does not make pushes wait for nature in any literal sense — it is a humorous, community-driven way to remind developers to step away from their screens, and it can be configured to block or delay a push until the developer confirms they have spent time outdoors. The phrase “touch grass” is internet slang for going outside and reconnecting with reality, and in the git context it is typically implemented as a pre-push or pre-commit hook that either pauses the operation, displays a message, or requires a manual override. This article explains what these hooks actually do, how to build one, and the practical considerations for using them.

What Does “Touch Grass” Mean in Developer Culture?

“Touch grass” emerged from online communities as a blunt way to tell someone they are spending too much time online or obsessing over a trivial issue. In software development, it has become a running joke: when a developer spends hours debugging a typo or agonizing over a pull request, a colleague might say “go touch grass.” The phrase implies that a short break outdoors will provide perspective and reduce stress.

In the git ecosystem, developers have turned this joke into actual tooling. A “touch grass” hook is a custom script that runs at a specific point in the git workflow, typically before a push or commit, and forces the developer to acknowledge that they have taken a break. The implementation varies: some simply print a reminder, others require a confirmation input, and a few go further by actually delaying the operation for a set time (e.g., 60 seconds) to encourage a brief pause.

How Git Hooks Work

Git hooks are scripts that Git executes automatically at key points in the version control lifecycle. They live in the .git/hooks/ directory of a repository and are not versioned by default (though they can be managed with tools like core.hooksPath). Each hook has a specific name and trigger:

• pre-commit: runs before a commit is created; can block the commit if it exits with a non-zero status.
• pre-push: runs before a push to a remote; can block the push if it exits with a non-zero status.
• commit-msg: runs after the commit message is written; can validate the message format.
• post-commit: runs after a commit is created; cannot affect the outcome.

The pre-push hook receives the remote name and URL as arguments, and reads the list of refs being pushed from standard input. If the script exits with a non-zero status, Git aborts the push. This makes it the ideal place for a “touch grass” reminder.

Building a Touch Grass Pre-Push Hook

To create a basic touch grass hook, you can write a shell script and place it in .git/hooks/pre-push. A simple version might look like this:

#!/bin/sh
echo "🌿 Have you touched grass today? (y/n)"
read answer
if [ "$answer" != "y" ]; then
  echo "Push aborted. Go outside for 5 minutes, then try again."
  exit 1
fi
exit 0

This script prompts the user for confirmation; if they do not answer “y”, the push is blocked. A more elaborate version could enforce a waiting period:

#!/bin/sh
echo "🌿 Take 30 seconds to look away from the screen. Then type 'grass' to continue."
read -t 30 answer
if [ "$answer" != "grass" ]; then
  echo "Push aborted. Touch grass and try again."
  exit 1
fi
exit 0

Note that read -t 30 gives the user 30 seconds to respond; if they time out, the push is aborted. This is a playful way to enforce a brief break.

How to Install and Manage the Hook

Hooks are per-repository, so you need to install the script in each clone where you want it. To share hooks across a team, you can use a hooks directory that is versioned, and then set core.hooksPath to point to it. For example:

1. Create a hooks/ directory in your repository and add your pre-push script there.
2. Commit the script (make it executable with chmod +x hooks/pre-push).
3. Instruct each developer to run git config core.hooksPath hooks in their local clone.

Alternatively, tools like Husky (for JavaScript projects) or pre-commit (a Python framework) can manage hooks automatically, but they are not required for a simple touch grass reminder.

Common Problems and Misconceptions

One misconception is that a touch grass hook will literally wait for the user to go outside. In reality, it only runs when the git command is executed — it cannot monitor physical activity. The hook can only pause the terminal until the user responds, which simulates a break but does not verify it.

Another issue is that hooks can be bypassed easily. A developer can simply delete the hook, edit the script, or use git push --no-verify (which skips all hooks). This is fine for a joke, but it means the hook is not a serious enforcement mechanism. If you want to prevent bypassing, you would need server-side hooks (on the remote repository), but those are controlled by the hosting service and cannot be customized in most cloud platforms.

Additionally, hooks that prompt for input can break automation scripts or CI/CD pipelines. If a push is triggered by a bot or a script, it will hang waiting for input. To avoid this, you can check if the terminal is interactive (if [ -t 0 ]) and skip the prompt if not.

Alternatives and Variations

If a blocking prompt is too intrusive, there are softer alternatives:

• Warning only: Print a message like “Remember to touch grass!” and exit 0, so the push proceeds.
• Random delay: Use sleep with a random duration (e.g., 5-15 seconds) to force a brief pause without user interaction.
• Commit message reminder: Add a pre-commit hook that checks if the commit message contains “WIP” and reminds the developer to take a break.
• External tools: Some developers use desktop apps that block the terminal or screen after a certain time, but these are not git-specific.

For teams that want to encourage work-life balance, a non-blocking reminder is often more effective than a hard block, because it does not frustrate users.

Frequently Asked Questions

Does a touch grass hook actually make my push wait?

Yes, if the script includes a sleep command or a prompt that requires input, the push will be delayed until the script finishes. However, it does not verify that you went outside; it only pauses the terminal.

Can I skip the hook if I’m in a hurry?

Yes, you can use git push --no-verify to bypass all hooks, or you can temporarily rename the hook file. This is a common escape hatch, but it defeats the purpose of the joke.

Will this work on Windows?

Yes, if you use Git for Windows (which includes a Bash shell), you can create shell scripts. Alternatively, you can write the hook in Python or PowerShell, as long as the file is executable and the shebang line points to the correct interpreter.

Is it safe to add a touch grass hook to a shared repository?

It is safe if it is non-blocking or if all team members agree to it. A blocking prompt can annoy users and break automation, so it is best to keep it optional or use the warning-only version.

How do I remove the hook?

Simply delete the .git/hooks/pre-push file (or the entire hooks directory if you set core.hooksPath). The change takes effect immediately.

Related

• Swift 101: Classes, Variables, Properties, and Methods
• Verify AI Documentary Claims With Primary Sources
• Why Human Judgment Still Matters in Generative AI