Commit Message Storyteller
OfficialFreeGenerate meaningful commit messages from your git diffs.
Free · Opens the source repo
What Commit Message Storyteller does
The Commit Message Storyteller skill is designed to enhance your version control practices by transforming raw git diffs and change descriptions into well-structured commit messages. These messages not only follow the Conventional Commits specification but also emphasize the intent and context behind your changes. Instead of generic messages like 'update file.js', this skill helps articulate the reasons for changes, making your commit history more informative and useful for future reference.
When you use this skill, it analyzes the changes in your codebase, whether they are staged files or raw diffs, to extract key information such as what changed, why it changed, and who or what triggered the change. This context is crucial for generating a narrative that explains the impact of your modifications. By adhering to the Conventional Commits format, it ensures that your commit messages are consistent and easily understandable, which is especially beneficial for team collaboration and open-source contributions.
The skill operates in a straightforward manner: after gathering the necessary context, it identifies the appropriate commit type (like feat, fix, or refactor) and constructs a commit message that includes a short imperative summary, a detailed body explaining the change, and a footer for issue references if applicable. This structured approach not only improves the clarity of your commit messages but also encourages best practices in version control.
Whether you're preparing for a pull request or just looking to maintain a clean commit history, the Commit Message Storyteller skill is a valuable tool for developers who want to communicate their changes effectively. It’s particularly useful in environments where understanding the rationale behind code changes is as important as the changes themselves.
When to use it
Use this skill when you need to generate a commit message from a git diff, staged changes, or a description of modifications.
When not to use it
It may not be suitable for very simple changes where a brief commit message suffices, or when you don't have any context to provide for the changes.
What you can build with it
Creating Detailed Commit Messages
When preparing a pull request, use this skill to generate detailed commit messages that explain the reasoning behind your changes.
Improving Team Collaboration
Utilize the skill to maintain a clear commit history, making it easier for team members to understand the context of changes.
Automating Commit Message Generation
Incorporate this skill into your workflow to automatically generate commit messages from git diffs, saving time and ensuring consistency.
How to install Commit Message Storyteller
View source1. Install with the skills CLI
npx skills add github/awesome-copilot/commit-message-storyteller --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by githubCommit Message Storyteller
Transforms raw git diffs and change descriptions into clear, story-driven commit messages that follow the Conventional Commits specification. Instead of "update file.js", you get messages that communicate intent, context, and impact.
When to Use This Skill
- User says "write a commit message", "help me commit", or "generate a commit"
- User pastes a git diff or describes code changes
- User says "what should I commit this as?" or "summarize my diff"
- User wants better commit history for their team or open-source project
- User is preparing a pull request and wants meaningful commit messages
Prerequisites
Have at least one of the following ready:
- Output from
git difforgit diff --staged - A description of what you changed and why
- A list of modified files
How It Works
Step 1: Gather the Change Context
Ask the user (or infer from the diff) for:
- What changed — files, functions, logic affected
- Why it changed — bug fix, new feature, refactor, performance, etc.
- Who/what triggered it — issue number, user request, tech debt, etc.
If the user provides a raw git diff, extract this context automatically from the diff.
Step 2: Identify the Commit Type
Map the change to a Conventional Commits type using this guide:
| Type | Use When |
|---|---|
feat | A new feature or capability is added |
fix | A bug or incorrect behavior is corrected |
refactor | Code restructured without changing behavior |
perf | A change that improves performance |
docs | Documentation only changes |
style | Formatting, whitespace, missing semicolons (no logic change) |
test | Adding or updating tests |
chore | Build process, dependency updates, config changes |
ci | CI/CD pipeline changes |
revert | Reverting a previous commit |
See references/conventional-commits-guide.md for detailed examples.
Step 3: Write the Commit Message
Follow this structure:
<type>(<optional scope>): <short imperative summary>
<body — the story: why this change was made, what problem it solves>
<footer — issue refs, breaking change notices>
Rules for Each Part
Subject line (first line):
- Use imperative mood: "add", "fix", "remove" — not "added" or "fixes"
- Max 72 characters
- No period at the end
- Lowercase after the colon
Body (the story):
- Explain the why, not the what (the diff already shows the what)
- Describe the problem that existed before this change
- Mention any alternatives considered if relevant
- Keep lines under 100 characters
- Separate from subject with a blank line
Footer:
- Reference issues:
Closes #123,Fixes #456,Refs #789 - Mark breaking changes:
BREAKING CHANGE: <description>
Step 4: Generate Output
Produce the commit message in a copyable code block, followed by a one-line plain-English explanation of the story you told.
Example output:
fix(auth): prevent token refresh loop on expired sessions
When a user's session expired mid-request, the auth middleware was
triggering a token refresh, which itself failed validation and triggered
another refresh — causing an infinite retry loop that crashed the app.
This adds a recursion guard flag that aborts the refresh cycle if a
refresh is already in progress, returning a clean 401 instead.
Closes #312
Story told: A silent infinite loop on session expiry was crashing the app; this stops the cycle early and returns a clean error.
Multiple Commits from One Diff
If the diff contains logically separate changes, split them into multiple commit messages and tell the user. Use this heuristic:
- Different files with unrelated purposes → likely separate commits
- Same file but distinct concerns (e.g., bug fix + refactor) → suggest splitting
- Everything tightly coupled → one commit is fine
Edge Cases
| Situation | How to Handle |
|---|---|
| User provides no context beyond a diff | Infer type and scope from file names and changed symbols |
| Changes span many files with no clear theme | Ask: "Is this one logical change, or multiple?" |
| Breaking change detected | Add BREAKING CHANGE: footer automatically |
| User says "keep it short" | Omit body, just write a strong subject line |
| No issue number available | Omit the footer entirely |
Quick Reference
# Get your staged diff to paste into Copilot
git diff --staged
# Or get the last uncommitted working tree changes
git diff
See references/conventional-commits-guide.md for type examples and scope guidelines.
Frequently asked questions about Commit Message Storyteller
Similar skills
Release Candidate Preparation
Streamline your OpenAI Agents release process.
Gitmoji
Generate expressive commit messages with emojis.
GitHub Release
Automate your GitHub library release process effortlessly.
Author Contributions
Trace author contributions across branches in Git.
Implementation Kickoff
Streamline your code implementation process with ease.
Git Flow Branch Creator
Automate Git Flow branch creation based on your changes.