In the world of software development, git has become an indispensable tool for version control, allowing teams to manage changes to their codebase efficiently. One crucial aspect of using git effectively is the ability to craft clear and concise commit messages, which provide a historical record of changes and the rationale behind them. To bring a level of consistency and readability to these messages, I’ve devised a simple yet powerful Bash function that automatically converts commit messages to Title Case, ensuring that each word gets the emphasis it deserves.

The Bash Function Explained

The function, simply named git(), intercepts your git commands and checks if you’re making a commit with a message. If so, it takes the commit message you’ve provided and converts it to Title Case before proceeding with the commit. Here’s a step-by-step breakdown:

Intercepting Git Commands

The function overrides the default git command, allowing it to process any arguments passed to git before potentially forwarding them to the actual git command. This is done using the command keyword, ensuring that we call the original git command to avoid recursion.

Identifying Commit Messages

It specifically looks for the pattern git commit -m, which is a common way to commit changes with a message directly from the command line. If this pattern is detected, the function proceeds to process the commit message.

Processing the Commit Message

The commit message, provided after the -m flag, is captured and then piped through an awk script. This script is where the magic happens: it converts the message to Title Case, making exceptions for certain small words (like “a”, “the”, “to”, etc.) that traditionally aren’t capitalized in titles unless they are the first word.

Executing the Commit

Once the message has been converted, the function executes the actual git commit -m command with the newly title-cased message. If the command is not a commit with a message, it simply forwards the command and its arguments to git unaltered.

The Code

git() {
    if [[ "$1" == "commit" && "$2" == "-m" ]]; then
        titleCasedMessage=$(echo "$commitMessage" | awk 'BEGIN{split("a the to at in on with and but or", w); for (i in w) nocap[w[i]]} {for (i=1; i<=NF; i++) $i = (tolower($i) in nocap && i > 1) ? tolower($i) : toupper(substr($i, 1, 1)) tolower(substr($i, 2))}1')
        command git commit -m "$titleCasedMessage"
        command git "$@"


  1. Consistency: Automatically formatting commit messages ensures a uniform style across a project’s history.
  2. Readability: Title-cased messages stand out and are easier to scan through when looking through git logs.
  3. Efficiency: It saves developers the effort of manually formatting commit messages, streamlining their workflow.


To use this function, simply add it to your .bashrc or .bash_profile and restart your terminal session. From then on, any commit message you make (using the git commit -m syntax) will automatically be converted to Title Case.

This simple Bash function exemplifies how small improvements in a development workflow can lead to more readable, professional, and consistent codebase management. By automating the formatting of commit messages, we not only enforce a standard but also save time and reduce the cognitive load on developers, allowing them to focus more on their code and less on administrative tasks.