commit

Creates Git commits from analyzed changes with conventional message formats.

2|Updated Dec 28, 2024
One-click install
npx skills add https://github.com/shonenm/dotfiles --skill commit-shonenm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/shonenm/dotfiles/tree/main/common/claude/.claude/skills/commit
Command: npx skills add https://github.com/shonenm/dotfiles --skill commit-shonenm

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill automates the creation of well-formatted Git commits by intelligently splitting your changes into logical units and generating descriptive messages, ensuring a clean and understandable commit history.

Core Features & Use Cases

  • Automated Commit Generation: Creates commits based on changes made within the current Claude session or all uncommitted changes.
  • Logical Change Segmentation: Divides modifications into distinct, atomic commits.
  • Conventional Commit Messages: Adheres to a standard format (prefix(scope): description) for clarity and automation.
  • Use Case: After a coding session where you've refactored a function, added a new feature, and updated documentation, use this Skill to create separate, meaningful commits for each logical change instead of one large, messy commit.

Quick Start

Use the commit skill to create commits for all changes made during this session.

Frequently Asked Questions about commit

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate writing conventional commit messages for multiple uncommitted changes?

Automating conventional commit messages involves analyzing uncommitted changes, segmenting them into logical units, and generating prefixed messages like 'feat' or 'fix' for each atomic commit. This process ensures a clean, understandable Git history without manual message crafting.

What is the best way to split a coding session into atomic Git commits?

Splitting a coding session into atomic Git commits requires analyzing modifications made during the session and dividing them into distinct logical units. Each unit is then staged and committed separately with a descriptive conventional commit message.

Can I generate Git commits for all uncommitted modifications without staging files manually?

Yes, you can generate Git commits for all uncommitted modifications by analyzing the working directory and automatically staging files into logical units. This process segments changes and applies conventional commit formats without requiring manual git add commands.

Does this Git commit tool prevent committing sensitive files like .env?

Yes, preventing sensitive files like .env from being committed is a built-in precaution. The commit generation process analyzes changes and explicitly avoids staging sensitive environment files to ensure secure code management.

When do I need to use conventional commit prefixes like feat and fix?

Conventional commit prefixes like 'feat', 'fix', and 'docs' are needed when you want to automate Git history parsing and maintain a structured changelog. They provide clarity by categorizing logical changes into atomic commits with standardized messages.

How does logical change segmentation work for Git commits?

Logical change segmentation for Git commits works by analyzing a set of modifications and dividing them into distinct, atomic units based on their purpose. Each unit is then assigned a conventional commit prefix and description to ensure a clean history.