conventional-commit

github/awesome-copilot

Generate standardized Conventional Commits messages with structured prompts and automated git workflows.

What is conventional-commit?

This skill provides a prompt template and workflow for creating Conventional Commits-compliant commit messages using structured XML formatting. It guides you through reviewing changes, constructing properly formatted commit messages, and automatically executing the commit via the integrated terminal.

Review staged and unstaged changes with git status and git diff
Construct commit messages using a structured XML template with type, scope, description, body, and footer
Validate commit message format against Conventional Commits specification
Automatically execute git commit commands through the integrated terminal
Support breaking changes and issue references in commit footers

How to install conventional-commit

npx skills add https://github.com/github/awesome-copilot --skill conventional-commit

Claude Code

Cursor

Windsurf

Cline

How to use conventional-commit

1.Run git status to review changed files
2.Run git diff or git diff --cached to inspect the changes
3.Stage your changes with git add <file>
4.Construct your commit message using the provided XML structure with type, scope, description, body (optional), and footer (optional)
5.Execute the prompt and Copilot will automatically run git commit with your message in the terminal

Use cases

Good for

Standardizing commit messages across a team or project
Generating semantic version-compatible commit history for automated changelog generation
Ensuring consistent commit message format in CI/CD pipelines
Documenting breaking changes and feature additions in a machine-readable format
Automating commit creation while maintaining conventional format standards

Who it's for

Developers using Conventional Commits specification
Teams implementing semantic versioning
Projects with automated changelog or release tooling
Anyone standardizing commit message conventions

conventional-commit FAQ

What are the allowed commit types?

The allowed types are: feat, fix, docs, style, refactor, perf, test, build, ci, chore, and revert. See https://www.conventionalcommits.org/en/v1.0.0/#specification for details.

Is the scope required?

No, scope is optional but recommended for clarity to indicate which part of the codebase the change affects.

How do I indicate a breaking change?

Add an exclamation mark after the type (e.g., feat!:) and include BREAKING CHANGE: details in the footer section.

Can I include additional context in my commit message?

Yes, use the optional body section for more detailed explanation and the footer section for breaking changes or issue references.

Full instructions (SKILL.md)

Source of truth, from github/awesome-copilot.

name: conventional-commit description: 'Prompt and workflow for generating conventional commit messages using a structured XML format. Guides users to create standardized, descriptive commit messages in line with the Conventional Commits specification, including instructions, examples, and validation.'

Instructions

	<description>This file contains a prompt template for generating conventional commit messages. It provides instructions, examples, and formatting guidelines to help users write standardized, descriptive commit messages in accordance with the Conventional Commits specification.</description>

Workflow

Follow these steps:

Run git status to review changed files.
Run git diff or git diff --cached to inspect changes.
Stage your changes with git add <file>.
Construct your commit message using the following XML structure.
After generating your commit message, Copilot will automatically run the following command in your integrated terminal (no confirmation needed):

git commit -m "type(scope): description"

Just execute this prompt and Copilot will handle the commit for you in the terminal.

Commit Message Structure

<commit-message>
	<type>feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert</type>
	<scope>()</scope>
	<description>A short, imperative summary of the change</description>
	<body>(optional: more detailed explanation)</body>
	<footer>(optional: e.g. BREAKING CHANGE: details, or issue references)</footer>
</commit-message>

Examples

<examples>
	<example>feat(parser): add ability to parse arrays</example>
	<example>fix(ui): correct button alignment</example>
	<example>docs: update README with usage instructions</example>
	<example>refactor: improve performance of data processing</example>
	<example>chore: update dependencies</example>
	<example>feat!: send email on registration (BREAKING CHANGE: email service required)</example>
</examples>

Validation

<validation>
	<type>Must be one of the allowed types. See <reference>https://www.conventionalcommits.org/en/v1.0.0/#specification</reference></type>
	<scope>Optional, but recommended for clarity.</scope>
	<description>Required. Use the imperative mood (e.g., "add", not "added").</description>
	<body>Optional. Use for additional context.</body>
	<footer>Use for breaking changes or issue references.</footer>
</validation>

Final Step

<final-step>
	<cmd>git commit -m "type(scope): description"</cmd>
	<note>Replace with your constructed message. Include body and footer if needed.</note>
</final-step>

Surgical code refactoring to improve maintainability without changing behavior.

19k installsAudited