Skip to content
Skillpedia
Deploy & cloud (DevOps)40k · #5165

git-commit

Lets your agent create Git commits intelligently. It analyzes changes, suggests messages, and helps stage files for commit.

What it does

This tool helps you create organized and standardized 'commit' messages for your code. It analyzes the changes you've made and suggests a clear description of what was altered, making it easier to track the project's history.

When to use it

  • ✓When you've finished making some code changes and want to save them.
  • ✓When you want to describe what changed clearly for yourself and others.
  • ✓When you want to follow a standard way to organize your project updates.

Example of what to ask your AI

“I want to save my code changes.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/github/awesome-copilot/blob/main/skills/git-commit/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/github/awesome-copilot/blob/main/skills/git-commit/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool looks at the differences between what you changed and what was already saved. Based on this, it suggests a type of change (like 'fix' or 'feature') and writes a brief description of what was done.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add github/awesome-copilot --skill git-commit

Or download just the file:

curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/git-commit/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Git Commit with Conventional Commits

Overview

Create standardized, semantic git commits using the Conventional Commits specification. Analyze the actual diff to determine appropriate type, scope, and message.

Conventional Commit Format

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

Commit Types

Type Purpose
feat New feature
fix Bug fix
docs Documentation only
style Formatting/style (no logic)
refactor Code refactor (no feature/fix)
perf Performance improvement
test Add/update tests
build Build system/dependencies
ci CI/config changes
chore Maintenance/misc
revert Revert commit

Breaking Changes

# Exclamation mark after type/scope
feat!: remove deprecated endpoint

# BREAKING CHANGE footer
feat: allow config to extend other configs

BREAKING CHANGE: `extends` key behavior changed

Workflow

1. Analyze Diff

# If files are staged, use staged diff
git diff --staged

# If nothing staged, use working tree diff
git diff

# Also check status
git status --porcelain

2. Stage Files (if needed)

If nothing is staged or you want to group changes differently:

# Stage specific files
git add path/to/file1 path/to/file2

# Stage by pattern
git add *.test.*
git add src/components/*

# Interactive staging
git add -p

Never commit secrets (.env, credentials.json, private keys).

3. Generate Commit Message

Analyze the diff to determine:

  • Type: What kind of change is this?
  • Scope: What area/module is affected?
  • Description: One-line summary of what changed (present tense, imperative mood, <72 chars)

4. Execute Commit

# Single line
git commit -m "<type>[scope]: <description>"

# Multi-line with body/footer
git commit -m "$(cat <<'EOF'
<type>[scope]: <description>

<optional body>

<optional footer>
EOF
)"

Best Practices

  • One logical change per commit
  • Present tense: "add" not "added"
  • Imperative mood: "fix bug" not "fixes bug"
  • Reference issues: Closes #123, Refs #456
  • Keep description under 72 characters

Git Safety Protocol

  • NEVER update git config
  • NEVER run destructive commands (--force, hard reset) without explicit request
  • NEVER skip hooks (--no-verify) unless user asks
  • NEVER force push to main/master
  • If commit fails due to hooks, fix and create NEW commit (don't amend)
FAQ

What is a 'commit'?

A 'commit' is like a save point in your code project. It records a set of changes you've made, along with a message explaining what was modified.

What are 'conventional commit messages'?

They are a standardized way of writing commit messages so they are easy to understand and can be used by other tools to organize the project history.

Can the tool stage files automatically?

Yes, it can help select which files were modified and are ready to be included in the commit, but it's always good to review before confirming.

Details

Original description by the author

Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff, (3) Interactive commit with optional type/scope/description overrides, (4) Intelligent file stagin

repo: github/awesome-copilot

Popularity

GitHub stars
40k
Ranking position
#5165
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills