The recent release of Cocommit, a tool designed to enhance Git commit messages using AI, has sparked a heated debate among developers about the fundamental purpose and best practices for writing commit messages. While some see AI assistance as a valuable enhancement to their workflow, others question whether automated tools address the real challenges of effective version control documentation.
The Purpose of Commit Messages Divides Developers
At the heart of the debate is a fundamental question: what makes a good commit message? Many developers in the discussion emphasized that commit messages should answer the crucial why question that future developers (including your future self) will ask when reviewing code history. This perspective aligns with Cocommit's stated goal of enhancing commit quality, but community members expressed skepticism about whether an AI tool can truly capture the contextual reasoning behind code changes.
I don't know why it's so hard for devs to stop for 30 seconds and answer the question why does this commit exist? That's the question you're going to ask when you find the commit in
git blame, so just answer it.
Some developers suggested that relying on AI to generate commit messages might be a red flag, indicating that the developer doesn't fully understand the changes they're making. Others argued that the diff already shows what changed, making verbose descriptions redundant, and that commit messages should focus on higher-level context that isn't obvious from the code changes themselves.
Key Points from Developer Discussion
- Purpose of commit messages: Should explain why changes were made, not just what changed
- Popular commit message approaches:
- Conventional Commits format (
feat:,fix:, etc.) - Git trailers for metadata
- Kernel patch descriptions
- Gitmoji (using emojis to indicate change types)
- Conventional Commits format (
- Suggested commit message frameworks:
- "When applied, this commit will..." as a mental prompt
- Answering "why does this commit exist?"
- Concerns about AI-generated messages:
- May not capture project-specific context
- Could enable developers who don't understand their changes
- Might produce verbose messages that don't add value
Standardization vs. Flexibility in Commit Formatting
The discussion revealed varying preferences regarding commit message formatting standards. Some developers advocated for following established conventions like Conventional Commits, which uses prefixes like feat: and fix: to categorize changes. Others argued against such rigid structures, suggesting that Git trailers might be a more flexible alternative that doesn't consume valuable space in the short message.
Interestingly, several developers agreed that having some standard—even one they personally dislike—is preferable to having no standard at all. This sentiment suggests that tools like Cocommit might find a place in helping teams maintain consistency in their commit messages, even if the specific format varies between projects.
AI as Assistant vs. AI as Replacement
A key distinction emerged between using AI to review and enhance human-written commit messages (which Cocommit appears designed to do) versus completely outsourcing the writing of commit messages to AI. Many developers expressed openness to the former while strongly opposing the latter.
Some comments suggested alternative use cases for AI in commit messages, such as decorating repositories that lack proper commit messages with synthetic guesswork or helping to standardize messages across large teams. These perspectives indicate that developers may be more receptive to AI tools that augment their existing workflows rather than replace human judgment entirely.
Brevity vs. Detail: Finding the Right Balance
The appropriate length and detail level for commit messages emerged as another contentious point. Some developers argued that just a few words is all that is needed, while others insisted that non-obvious changes require more comprehensive explanations. This debate highlights the challenge that AI tools like Cocommit face in determining the appropriate level of detail for different types of changes.
Several developers suggested a balanced approach where code comments explain implementation details while commit messages focus on the rationale for changes. This distinction between what and why appears to be a guiding principle that many experienced developers follow, regardless of their stance on message length or formatting.
In conclusion, while tools like Cocommit offer potential benefits for maintaining consistent, informative commit histories, the developer community remains divided on whether AI assistance addresses the core challenges of writing good commit messages. The most valuable commit messages appear to be those that clearly communicate intent and context—something that requires human understanding of both the code and the broader project goals. Whether AI can effectively augment this process without diminishing its value remains an open question that will likely continue to evolve as these tools mature.
Reference: Cocommit: A Copilot for Git