How to Write a Git Commit Message

Contents: Introduction | The Seven Rules | Tips

Introduction: Why good commit messages matter

If you browse the log of any random Git repository, you’ll in all probability discover its commit messages are kind of a multitude. For instance, check out these gems from my early days committing to Spring:

$ git log --oneline -5 --author cbeams --before "Fri Mar 26 2009"

e5f4b49 Re-adding ConfigurationPublishProcessorTests after its transient elimination in r814. @Ignore-ing the testCglibClassesAreLoadedJustInTimeForEnhancement() technique because it seems this was one of many culprits within the current construct breakage. The classloader hacking causes delicate downstream results, breaking unrelated assessments. The check technique remains to be helpful, however ought to solely be run on a handbook foundation to make sure CGLIB shouldn't be prematurely classloaded, and shouldn't be run as a part of the automated construct.
2db0f12 mounted two build-breaking points: + reverted ClassMetadataReadingVisitor to revision 794 + eradicated ConfigurationPublishProcessorTests till additional investigation determines why it causes downstream assessments to fail (such because the seemingly unrelated ClassPathXmlApplicationContextTests)
147709f Tweaks to information
22b25e0 Consolidated Util and MutableAnnotationUtils lessons into current AsmUtils
7f96f57 sharpening

Yikes. Compare that with these newer commits from the identical repository:

$ git log --oneline -5 --author pwebb --before "Sat Aug 30 2014"

5ba3db6 Fix failing CompositePropertySourceExams
84564a0 Rework @PropertySource early parsing logic
e142fd1 Add assessments for ImportSelector meta-data
887815f Update docbook dependency and generate epub
ac8326d Polish mockito utilization

Which would you somewhat learn?

The former varies in size and kind; the latter is concise and constant.
The former is what occurs by default; the latter by no means occurs by chance.

While many repositories’ logs seem like the previous, there are exceptions. The Linux kernel and Git itself are nice examples. Look at Spring Boot, or any repository managed by Tim Pope.

The contributors to those repositories know {that a} well-crafted Git commit message is one of the simplest ways to speak context a couple of change to fellow builders (and certainly to their future selves). A diff will let you know what modified, however solely the commit message can correctly let you know why. Peter Hutterer makes this level effectively:

Re-establishing the context of a chunk of code is wasteful. We can’t keep away from it utterly, so our efforts ought to go to decreasing it [as much] as attainable. Commit messages can do precisely that and in consequence, a commit message exhibits whether or not a developer is an effective collaborator.

If you haven’t given a lot thought to what makes an amazing Git commit message, it might be the case that you simply haven’t spent a lot time utilizing git log and associated instruments. There is a vicious cycle right here: as a result of the commit historical past is unstructured and inconsistent, one doesn’t spend a lot time utilizing or caring for it. And as a result of it doesn’t get used or taken care of, it stays unstructured and inconsistent.

But a well-cared for log is a phenomenal and helpful factor. git blame, revert, rebase, log, shortlog and different subcommands come to life. Reviewing others’ commits and pull requests turns into one thing value doing, and out of the blue could be carried out independently. Understanding why one thing occurred months or years in the past turns into not solely attainable however environment friendly.

A mission’s long-term success rests (amongst different issues) on its maintainability, and a maintainer has few instruments extra highly effective than his mission’s log. It’s value taking the time to discover ways to look after one correctly. What could also be a trouble at first quickly turns into behavior, and ultimately a supply of pleasure and productiveness for all concerned.

In this put up, I’m addressing simply essentially the most fundamental ingredient of maintaining a wholesome commit historical past: the best way to write a person commit message. There are different vital practices like commit squashing that I’m not addressing right here. Perhaps I’ll do this in a subsequent put up.

Most programming languages have well-established conventions as to what constitutes idiomatic fashion, i.e. naming, formatting and so forth. There are variations on these conventions, in fact, however most builders agree that choosing one and sticking to it is much better than the chaos that ensues when all people does their very own factor.

A crew’s method to its commit log needs to be no completely different. In order to create a helpful revision historical past, groups ought to first agree on a commit message conference that defines at the very least the next three issues:

Style. Markup syntax, wrap margins, grammar, capitalization, punctuation. Spell this stuff out, take away the guesswork, and make all of it so simple as attainable. The finish consequence shall be a remarkably constant log that’s not solely a pleasure to learn however that truly does get learn frequently.

Content. What type of data ought to the physique of the commit message (if any) comprise? What ought to it not comprise?

Metadata. How ought to difficulty monitoring IDs, pull request numbers, and many others. be referenced?

Fortunately, there are well-established conventions as to what makes an idiomatic Git commit message. Indeed, a lot of them are assumed in the way in which sure Git instructions perform. There’s nothing it’s essential to re-invent. Just observe the seven guidelines under and also you’re in your technique to committing like a professional.

The seven guidelines of an amazing Git commit message

Keep in thoughts: This has all been stated earlier than.

  1. Separate topic from physique with a clean line
  2. Limit the topic line to 50 characters
  3. Capitalize the topic line
  4. Do not finish the topic line with a interval
  5. Use the crucial temper within the topic line
  6. Wrap the physique at 72 characters
  7. Use the physique to clarify what and why vs. how

For instance:

Summarize modifications in round 50 characters or much less

More detailed explanatory textual content, if crucial. Wrap it to about 72
characters or so. In some contexts, the primary line is handled because the
topic of the commit and the remainder of the textual content because the physique. The
clean line separating the abstract from the physique is essential (until
you omit the physique fully); varied instruments like `log`, `shortlog`
and `rebase` can get confused should you run the 2 collectively.

Explain the issue that this commit is fixing. Focus on why you
are making this variation versus how (the code explains that).
Are there uncomfortable side effects or different unintuitive penalties of this
change? Here's the place to clarify them.

Further paragraphs come after clean strains.

 - Bullet factors are okay, too

 - Typically a hyphen or asterisk is used for the bullet, preceded
   by a single house, with clean strains in between, however conventions
   differ right here

If you employ a difficulty tracker, put references to them on the backside,
like this:

Resolves: #123
See additionally: #456, #789

1. Separate topic from physique with a clean line

From the git commit manpage:

Though not required, it’s a good suggestion to start the commit message with a single brief (lower than 50 character) line summarizing the change, adopted by a clean line after which a extra thorough description. The textual content as much as the primary clean line in a commit message is handled because the commit title, and that title is used all through Git. For instance, Git-format-patch(1) turns a commit into e mail, and it makes use of the title on the Subject line and the remainder of the commit within the physique.

Firstly, not each commit requires each a topic and a physique. Sometimes a single line is ok, particularly when the change is so easy that no additional context is critical. For instance:

Fix typo in introduction to consumer information

Nothing extra want be stated; if the reader wonders what the typo was, she will merely check out the change itself, i.e. use git present or git diff or git log -p.

If you’re committing one thing like this on the command line, it’s straightforward to make use of the -m choice to git commit:

$ git commit -m"Fix typo in introduction to user guide"

However, when a commit deserves a little bit of rationalization and context, it’s essential to write a physique. For instance:

Derezz the grasp management program

MCP turned out to be evil and had turn out to be intent on world domination.
This commit throws Tron's disc into MCP (inflicting its deresolution)
and turns it again right into a chess sport.

Commit messages with our bodies should not really easy to jot down with the -m choice. You’re higher off writing the message in a correct textual content editor. If you don’t have already got an editor arrange to be used with Git on the command line, learn this part of Pro Git.

In any case, the separation of topic from physique pays off when shopping the log. Here’s the complete log entry:

$ git log
commit 42e769bdf4894310333942ffc5a15151222a87be
Author: Kevin Flynn <>
Date:   Fri Jan 01 00:00:00 1982 -0200

 Derezz the grasp management program

 MCP turned out to be evil and had turn out to be intent on world domination.
 This commit throws Tron's disc into MCP (inflicting its deresolution)
 and turns it again right into a chess sport.

And now git log --oneline, which prints out simply the topic line:

$ git log --oneline
42e769 Derezz the grasp management program

Or, git shortlog, which teams commits by consumer, once more exhibiting simply the topic line for concision:

$ git shortlog
Kevin Flynn (1):
      Derezz the grasp management program

Alan Bradley (1):
      Introduce safety program "Tron"

Ed Dillinger (3):
      Rename chess program to "MCP"
      Modify chess program
      Upgrade chess program

Walter Gibbs (1):
      Introduce protoype chess program

There are quite a lot of different contexts in Git the place the excellence between topic line and physique kicks in—however none of them work correctly with out the clean line in between.

2. Limit the topic line to 50 characters

50 characters shouldn’t be a tough restrict, only a rule of thumb. Keeping topic strains at this size ensures that they’re readable, and forces the creator to assume for a second about essentially the most concise technique to clarify what’s occurring.

Tip: If you’re having a tough time summarizing, you is perhaps committing too many modifications without delay. Strive for atomic commits (a subject for a separate put up).

GitHub’s UI is absolutely conscious of those conventions. It will warn you should you go previous the 50 character restrict:


And will truncate any topic line longer than 72 characters with an ellipsis:


So shoot for 50 characters, however contemplate 72 the exhausting restrict.

3. Capitalize the topic line

This is so simple as it sounds. Begin all topic strains with a capital letter.

For instance:

  • Accelerate to 88 miles per hour

Instead of:

  • speed up to 88 miles per hour

4. Do not finish the topic line with a interval

Trailing punctuation is pointless in topic strains. Besides, house is treasured whenever you’re attempting to maintain them to 50 chars or much less.


Instead of:

5. Use the crucial temper within the topic line

Imperative temper simply means “spoken or written as if giving a command or instruction”. Just a few examples:

  • Clean your room
  • Close the door
  • Take out the trash

Each of the seven guidelines you’re studying about proper now are written within the crucial (“Wrap the body at 72 characters”, and many others.).

The crucial can sound slightly impolite; that’s why we don’t usually use it. But it’s good for Git commit topic strains. One cause for that is that Git itself makes use of the crucial each time it creates a commit in your behalf.

For instance, the default message created when utilizing git merge reads:

Merge department 'myfeature'

And when utilizing git revert:

Revert "Add the thing with the stuff"

This reverts commit cc87791524aedd593cff5a74532befe7ab69ce9d.

Or when clicking the “Merge” button on a GitHub pull request:

Merge pull request #123 from someuser/somebranch

So whenever you write your commit messages within the crucial, you’re following Git’s personal built-in conventions. For instance:

  • Refactor subsystem X for readability
  • Update getting began documentation
  • Remove deprecated strategies
  • Release model 1.0.0

Writing this manner is usually a little awkward at first. We’re extra used to talking within the indicative temper, which is all about reporting info. That’s why commit messages usually find yourself studying like this:

  • Fixed bug with Y
  • Changing conduct of X

And typically commit messages get written as an outline of their contents:

  • More fixes for damaged stuff
  • Sweet new API strategies

To take away any confusion, right here’s a easy rule to get it proper each time.

A correctly fashioned Git commit topic line ought to at all times be capable of full the next sentence:

  • If utilized, this commit will your topic line right here

For instance:

  • If utilized, this commit will refactor subsystem X for readability
  • If utilized, this commit will replace getting began documentation
  • If utilized, this commit will take away deprecated strategies
  • If utilized, this commit will launch model 1.0.0
  • If utilized, this commit will merge pull request #123 from consumer/department

Notice how this doesn’t work for the opposite non-imperative kinds:

  • If utilized, this commit will mounted bug with Y
  • If utilized, this commit will altering conduct of X
  • If utilized, this commit will extra fixes for damaged stuff
  • If utilized, this commit will candy new API strategies

Remember: Use of the crucial is vital solely within the topic line. You can loosen up this restriction whenever you’re writing the physique.

6. Wrap the physique at 72 characters

Git by no means wraps textual content mechanically. When you write the physique of a commit message, it’s essential to thoughts its proper margin, and wrap textual content manually.

The suggestion is to do that at 72 characters, in order that Git has loads of room to indent textual content whereas nonetheless maintaining the whole lot underneath 80 characters total.

An excellent textual content editor will help right here. It’s straightforward to configure Vim, for instance, to wrap textual content at 72 characters whenever you’re writing a Git commit. Traditionally, nevertheless, IDEs have been horrible at offering sensible assist for textual content wrapping in commit messages (though in current variations, IntelliJ IDEA has lastly gotten higher about this).

7. Use the physique to clarify what and why vs. how

This commit from Bitcoin Core is a good instance of explaining what modified and why:

commit eb0b56b19017ab5c16c745e6da39c53126924ed6
Author: Pieter Wuille <>
Date:   Fri Aug 1 22:57:55 2014 +0200

   Simplify serialize.h's exception dealing with

   Remove the 'state' and 'exceptmask' from serialize.h's stream
   implementations, in addition to associated strategies.

   As exceptmask at all times included 'failbit', and setstate was at all times
   referred to as with bits = failbit, all it did was instantly elevate an
   exception. Get rid of these variables, and substitute the setstate
   with direct exception throwing (which additionally removes some useless

   As a consequence, good() isn't reached after a failure (there are
   solely 2 calls, one among which is in assessments), and might simply get replaced
   by !eof().

   fail(), clear(n) and exceptions() are simply by no means referred to as. Delete

Take a have a look at the full diff and simply assume how a lot time the creator is saving fellow and future committers by taking the time to supply this context right here and now. If he didn’t, it will in all probability be misplaced endlessly.

In most instances, you may miss particulars about how a change has been made. Code is usually self-explanatory on this regard (and if the code is so advanced that it must be defined in prose, that’s what supply feedback are for). Just deal with making clear the the reason why you made the change within the first place—the way in which issues labored earlier than the change (and what was mistaken with that), the way in which they work now, and why you determined to unravel it the way in which you probably did.

The future maintainer that thanks you might be your self!


Learn to like the command line. Leave the IDE behind.

For as many causes as there are Git subcommands, it’s clever to embrace the command line. Git is insanely highly effective; IDEs are too, however every in several methods. I take advantage of an IDE every single day (IntelliJ IDEA) and have used others extensively (Eclipse), however I’ve by no means seen IDE integration for Git that might start to match the benefit and energy of the command line (as soon as you realize it).

Certain Git-related IDE features are invaluable, like calling git rm whenever you delete a file, and doing the suitable stuff with git whenever you rename one. Where the whole lot falls aside is whenever you begin attempting to commit, merge, rebase, or do subtle historical past evaluation by the IDE.

When it involves wielding the complete energy of Git, it’s command-line all the way in which.

Remember that whether or not you employ Bash or Zsh or Powershell, there are tab completion scripts that take a lot of the ache out of remembering the subcommands and switches.

Read Pro Git

The Pro Git ebook is on the market on-line free of charge, and it’s unbelievable. Take benefit!

header picture credit score: xkcd

Source hyperlink

Leave a Reply

Your email address will not be published.