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

Ready to run

npx skills add https://github.com/nabi-chan/dotfiles --skill commit-nabi-chan

💬 Prompt for ChatGPT / Claude Chat▼

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.