If you’ve ever wondered, "Who wrote this line of code?" or "When was this change introduced?", then git blame is the tool you need in your Git arsenal. As a software engineer, I’ve found git blame to be invaluable for tracking down bugs, understanding code history, and uncovering the reasons behind tricky lines of code.

In this article, I’ll show you how to use git blame effectively, along with some tips and tricks to supercharge your workflow.

What is Git Blame?

git blame shows you, line by line, which commit last modified each line of a file. This lets you see who authored each line, when it was changed, and the commit hash associated with that change. It’s incredibly useful when you want to investigate the history of a specific piece of code without having to dig through endless commit logs.

Basic Usage

To get started, simply run:

git blame <filename>

For example:

git blame main.py

The output will show, for each line:

• The commit hash
• The author
• The date
• The line content

Taming the Output: Useful Blame Options

The default output can be quite dense. Here are some options to make your investigation smoother:

• -e: Show the author’s email instead of their name.

  git blame -e main.py
  

• -L <start>,<end>: Limit blame to specific line ranges. For example, show blame for lines 20–40:

  git blame -L 20,40 main.py
  

• -C: Track lines that have been moved or copied from other files.
• -w: Ignore changes in whitespace.

Combining with Other Git Tools

It’s often helpful to combine git blame with other commands:

• Opening the commit: Once you identify an interesting commit hash, you can run:

  git show <commit>
  

• Viewing the commit in a GUI: If you use a visual Git tool (like GitLens for VS Code), most support inline blame and easy navigation to the commit details.

Practical Scenarios Where git blame Shines

• Debugging regressions: Find out when and why a troublesome line was changed.
• Understanding legacy code: Learn who to ask for context, or locate the commit message that explains an odd implementation.
• Audits: Track accountability for changes in sensitive or security-critical areas.

Pro Tip: Avoid Witch Hunts

While git blame is powerful, remember it’s a tool for understanding, not assigning blame. Development is a team sport, and context is key. Use the tool to learn and improve, not to single out contributors.

Conclusion

When used wisely, git blame can help you dig into your code history with confidence. Whether you’re maintaining a massive legacy project or contributing to a small team repo, this command is an essential part of any Git workflow.

Happy blaming (the tool, not your teammates)!

---

Joe Git is a software engineer passionate about writing clean code and making the most of Git. Check out his previous articles for more pro tips!