skills.rest
nabi-chan
nabi-chanCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

commit

Organize Git changes into atomic commits with conventional commit messages.

Updated Jun 18, 2026
Search Tags:#git#version control#commit#conventional commits#code history#atomic commits
One-click install
npx skills add https://github.com/nabi-chan/dotfiles --skill commit-nabi-chan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/nabi-chan/dotfiles/tree/main/dot_claude/skills/commit
Command: npx skills add https://github.com/nabi-chan/dotfiles --skill commit-nabi-chan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill helps you break down large sets of changes into small, logical, and independent commits, making your Git history cleaner, more understandable, and easier to manage.

Core Features & Use Cases

  • Logical Unit Separation: Automatically identifies and groups related file changes.
  • Atomic Committing: Guides the user to create individual commits for each logical unit of work.
  • Conventional Commits: Enforces a standardized format for commit messages (e.g., feat:, fix:).
  • Use Case: After a long development session, you have multiple unrelated changes. This Skill helps you separate them into distinct commits for new features, bug fixes, and chores, ensuring a clean and traceable history.

Quick Start

Use the commit skill to review my current changes and help me create atomic commits.

Frequently Asked Questions about commit

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

FAQPage Schema
How do I split unrelated changes into separate Git commits?▼

To split unrelated changes into separate Git commits, this Skill analyzes modifications and groups them into logical units like features or fixes, prompting you to confirm staging and committing each group independently.

What are atomic commits and when do I need them in version control?▼

Atomic commits are small, independent commits that group related file changes together. You need them in version control to keep your code history clean, traceable, and maintainable, especially after long development sessions with mixed updates.

How to generate conventional commit messages for staged file changes?▼

To generate conventional commit messages, this Skill categorizes your changes into logical units and enforces a standardized format using prefixes like feat: and fix:, ensuring a consistent and readable Git history.

Can I review changes before creating atomic commits?▼

Yes, you can review changes before creating atomic commits. This Skill prompts you for confirmation before staging and committing each categorized logical unit, ensuring unrelated modifications are not bundled together.

What is the best way to organize a messy Git history after a long session?▼

The best way to organize a messy Git history is to identify related file modifications and commit them as separate logical units using conventional commit standards, ensuring unrelated changes remain independent and traceable.

Does this Skill require manual staging before separating commits?▼

No, manual staging is not required before separating commits. This Skill analyzes your current modifications, categorizes them into logical units, and handles the staging and committing process after prompting for your confirmation.

Related Skills

Explore More Software Engineering Skills→
mkittmkitt
6

commit-groups

Analyze uncommitted Git changes to propose logical commit groupings.

Community
Intermediate
AstrumonAstrumon

changelog-generator

Generate Keep a Changelog entries from Conventional Commits history.

Community
Intermediate
kid-sidkid-sid
18

git-workflow

Enforce conventional commits, branch naming, and safe force-push rules in Git workflows.

Community
Intermediate
epologeeepologee
3

commit-all-the-things

Group git working tree changes into logical commits without pushing.

Community
Intermediate