commit-chunks

Group uncommitted Git changes into atomic commits with conventional messages.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/ameyalambat128/dotfiles --skill commit-chunks
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit-chunks
Source: https://github.com/ameyalambat128/dotfiles/tree/main/claude/skills/commit-chunks
Command: npx skills add https://github.com/ameyalambat128/dotfiles --skill commit-chunks

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you break large sets of uncommitted changes into small, logical, atomic commits, reducing risk and improving history readability.

Core Features & Use Cases

  • Atomic Commits: Group related changes into single commits that each have a clear purpose.
  • Guided Messaging: Use conventional commit formats to describe intent.
  • Review & Log: After committing, display a short log of what changed.

Quick Start

Run this workflow on your repository to review uncommitted changes, group them into commits, stage files selectively, and commit with clear messages. For example, start with git status and git diff, then create one commit per logical change and push to your branch.

Frequently Asked Questions about commit-chunks

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

FAQPage Schema
How do I organize uncommitted changes into atomic commits?

Atomic commits group related changes into single, purposeful commits. Use git status and git diff to review your changes, then stage related files with git add and commit each group with a conventional message (feat, fix, chore, docs, refactor, style). This reduces risk and improves history readability across feature work, bug fixes, refactors, and documentation updates.

What's the best way to write commit messages for multiple file changes?

Use conventional commit format with a type prefix—feat, fix, chore, docs, refactor, or style—followed by a clear, concise description of what changed and why. Each commit should represent one logical change, making your Git history scannable and easier to bisect or revert.

Can I break large uncommitted changes into separate commits automatically?

This Skill identifies uncommitted changes across multiple files and groups them into meaningful, atomic commits by staging relevant files selectively and applying conventional commit messages. You review the changes, decide logical groupings, then the workflow handles staging and committing with a final summary via git log.

When should I use atomic commits instead of one large commit?

Atomic commits are essential when you have edits spanning multiple files for different purposes—feature additions, bug fixes, refactors, or chores. Each logical unit in its own commit makes code review clearer, enables precise git bisect searches, and lets you revert individual changes without affecting unrelated work.

Does this workflow work with existing Git repositories?

Yes, this Skill applies to local Git repositories with uncommitted edits. It's designed for feature branches, bug fixes, refactors, chores, and documentation updates on any repository where you have unstaged changes across one or more files.

What happens after I create commits with this workflow?

After staging and committing each logical group with conventional messages, the workflow displays a summary using git log --oneline -10, showing your latest commits. You can then review the changes, verify they're correct, and push to your branch.

Related Skills