Good Commit ✅ vs. Bad Commit ❌: Git Best Practices

Version control is a cornerstone of effective collaboration in software and web development. Git, one of the most widely-used version control tools, allows developers to track changes, revert to previous states, and collaborate efficiently. However, Git's true potential is realized only when commits are handled thoughtfully.

This guide covers the traits of both good and bad commits, along with practical tips for maintaining a clear and valuable commit history.

---

Characteristics of a Good Commit

1. Atomic and Focused

A good commit should represent a single, logical change. Avoid bundling multiple unrelated changes into a single commit.

Example:

# Good commit
$ git commit -m "Implement user authentication"

# Bad commit
$ git commit -m "Implement user authentication and update UI styles"

2. Clear and Informative Messages

Commit messages should clearly describe what was changed and why. Provide enough detail so that others (or your future self) can understand the purpose without diving into the code.

Example:

# Good commit message
$ git commit -m "Fix null pointer exception during user login"

# Bad commit message
$ git commit -m "Fix issue"

3. Follow Conventional Commit Guidelines

Using standardized commit message formats helps maintain a consistent and understandable history. Common conventions include specifying a type (e.g., feat, fix, refactor, docs) and a brief summary, with optional additional context or references.

Example:

# Good commit messages using conventions
$ git commit -m "feat(auth): add JWT-based authentication"
$ git commit -m "fix(login): resolve race condition in login flow"

4. Thoroughly Tested

Before committing, ensure that your changes are properly tested. Untested or broken code can cause significant disruptions for your team.

5. Well-Scoped Changes

Keep your commits scoped to a specific task or feature. Including all relevant changes for a particular update in one commit helps maintain consistency and avoids confusion.

Example:

# Good commit with appropriate scope
$ git commit -m "refactor(auth): separate authentication logic into a standalone module"

# Bad commit with mixed scope
$ git commit -m "Refactor and minor fixes"

---

Characteristics of a Bad Commit

1. Too Large or Unfocused

Commits that include numerous changes are difficult to review and understand. They make debugging and code management more challenging.

Example:

# Bad commit
$ git commit -m "Update the entire project"

2. Unclear or Misleading Messages

A vague commit message fails to convey the purpose of the changes. This can create confusion and hinder collaboration.

Example:

# Bad commit message
$ git commit -m "Stuff"

3. Combining Unrelated Changes

Bundling unrelated updates into a single commit complicates tracking and reviewing changes. It can also introduce unexpected bugs.

Example:

# Bad commit
$ git commit -m "Update README and fix login issue"

4. Incomplete or Untested Code

Committing unfinished or untested work disrupts the workflow and can break builds, negatively affecting the entire team.

5. Lacking Context

Commits without context make it difficult to understand why a change was made, complicating future troubleshooting and updates.

---

Best Practices for Good Commits

1. Commit at Meaningful Intervals

Strike a balance between committing too often and too rarely. Each commit should represent a meaningful, standalone change. Avoid mixing unrelated updates in a single commit.

2. Write Clear, Descriptive Messages

Make sure your commit messages succinctly describe the "what" and "why" of your changes.

3. Leverage Feature Branches

Use branches for distinct tasks such as new features, bug fixes, or experiments. Submit pull requests for these branches to enable code review before merging into the main branch.

4. Review and Organize Commits Before Merging

When preparing to merge a branch, consolidate small or "fixup" commits into logical units. This practice ensures a clean and comprehensible commit history.

5. Automate Code Testing

Incorporate continuous integration tools to verify your code with each commit. Automated testing helps catch issues early and maintains code quality.

6. Use Tools Like Husky

Husky can enforce commit standards by preventing non-compliant commits. This helps ensure consistent and clean Git history.

---

Conclusion

Maintaining a good commit history is key to managing projects efficiently with Git. By creating atomic commits, writing meaningful messages, and following best practices, you can enhance collaboration and make your codebase more maintainable.

We at Oxlac follow these practices to ensure the highest standards in version control. Our commitment to clean and efficient project management reflects our dedication to delivering top-notch solutions to our clients. Whether it’s a small project or a large-scale application, we take every client’s project seriously and work diligently to exceed expectations.