AI Prompts for Git Commit Messages

Write a git commit message for this change: [DESCRIBE OR PASTE CODE CHANGE]. Follow this format: a subject line under 72 characters that starts with an imperative verb (add, fix, update, remove, refactor), a blank line, and a body that explains why the change was made and any non-obvious context a future developer would need. Do not just describe what the diff shows; explain the reasoning.

Write a conventional commit message for this change: [DESCRIBE CHANGE]. Use the format: type(scope): description. Types: feat (new feature), fix (bug fix), docs, style, refactor, test, chore. The scope is the part of the codebase affected. Body should explain the motivation and what changed. If it is a breaking change, add BREAKING CHANGE: in the footer.

Write a commit message for this bug fix: [DESCRIBE BUG AND FIX]. The message should: reference the issue number [ISSUE NUMBER] if applicable, describe what was broken in the subject line, and explain in the body: what the root cause was, what the fix does, and any edge cases it handles that the original code did not.

Write a commit message for this refactoring: [DESCRIBE REFACTOR]. The subject should make clear this is a refactor (no behavior change). The body should explain: why the refactor was needed, what makes the new version better, and any risks or dependencies that other developers should know about.

Write a commit message for updating [DEPENDENCY NAME] from [OLD VERSION] to [NEW VERSION]. Include: what changed in the new version that matters for this project, why the update was done now, and any breaking changes or code updates that were required as part of the upgrade.

These commit messages are too vague: [LIST MESSAGES]. Rewrite each one to be more descriptive and useful. For each rewrite, I will give you the original message and a brief description of what the commit actually changed: [PASTE PAIRS]. The rewrite should tell the story of why this change happened, not just what files changed.

I have a large pull request that touches many files across [DESCRIBE SCOPE OF CHANGES]. Help me write: a single PR title and description that summarizes the overall change, and break the changes into logical commit groups with a message for each group. The goal is a clean, reviewable commit history that tells the story of the change in order.

I tend to make large commits that bundle many unrelated changes. Explain the principle of atomic commits: what makes a commit atomic, how to identify when a commit should be split, and how to restructure my workflow so I commit in smaller logical units without losing work. Give me a practical workflow I can start using today.

I am squashing these commits into one: [LIST COMMIT MESSAGES]. Write a single commit message that captures all the changes coherently. The subject should describe the overall feature or fix. The body should summarize the most important individual changes and the overall motivation.

I am tagging version [VERSION NUMBER] of [PROJECT NAME] for release. Write a commit message for the version bump and a release tag description. The changes in this release are: [LIST KEY CHANGES]. The message should be suitable for a public changelog.

Write a commit message guide for my engineering team. Include: the format we use (conventional commits or custom), examples of good and bad messages for each type of change, how to reference issues and pull requests, when to include a body versus just a subject, and the git hook or linting setup to enforce the standard.

Write a commitlint configuration for this project that enforces [DESCRIBE YOUR COMMIT CONVENTION]. Include: the .commitlintrc file, a pre-commit hook setup using husky or lefthook, and the error messages developers will see when their commit message does not conform. Make the error messages helpful rather than just saying the format is wrong.

Here are the last 20 commit messages from my team's repository: [PASTE MESSAGES]. Assess the quality of this commit history. What patterns of poor commit messages do you see? What information is typically missing? Write a short guide specifically addressing the problems I see in this history.

Write a git commit template (a .gitmessage file) that my team can use as a starting point for every commit. The template should prompt for: the type and scope, a concise subject line, the motivation for the change, any breaking changes, and a reference to the related issue or ticket. Keep it concise and fill-in-the-blank friendly.

I want to include commit message examples in our developer onboarding guide. Write 8 to 10 example commit messages covering the most common scenarios in [TYPE OF PROJECT]: new features, bug fixes, refactoring, dependency updates, documentation, tests, configuration changes, and performance improvements. Each example should be the kind of commit message a developer would actually write.

I need to find when and why a specific change was made in this codebase. The change involves: [DESCRIBE]. Help me write git commands to: search commit messages for relevant terms, find when a specific line or function was last changed, trace the history of a specific file, and find the commit that introduced a specific bug.

Write a CHANGELOG entry for version [VERSION] from these git commits: [PASTE COMMIT MESSAGES]. Group the changes by type: new features, bug fixes, improvements, and breaking changes. Write each entry as a complete sentence that describes the change from a user's perspective, not a developer's perspective.

I have a bug that was introduced somewhere between commit [COMMIT A] and [COMMIT B]. Walk me through using git bisect to find the exact commit that introduced it. Write the commands I need to run, explain how to evaluate each commit during the bisect, and what to do when git bisect finds the bad commit.

I am making a controversial architectural decision that future developers will question: [DESCRIBE DECISION]. Write a commit message that documents this decision in a way that will help future developers understand why it was made, what alternatives were considered, and what conditions would make it appropriate to revisit the decision.

When reviewing this code, I want to understand the context of when and why it was written. Here are the git blame entries for the relevant lines: [PASTE BLAME OUTPUT]. Help me interpret what the history tells me about the intent of the original code and whether the current behavior matches that original intent.