Atomic Commit Skill

Generate atomic-commit plans from current changes using Python and Bash tooling.

9|2|Updated Oct 13, 2025
One-click install
npx skills add https://github.com/dhofheinz/open-plugins --skill atomic-commit-skill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Atomic Commit Skill
Source: https://github.com/dhofheinz/open-plugins/tree/main/plugins/git-commit-assistant/commands/atomic-commit
Command: npx skills add https://github.com/dhofheinz/open-plugins --skill atomic-commit-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

Creating atomic commits (each representing a single, logical change) is a best practice that simplifies code reviews and debugging, but it can be challenging to break down complex changes into smaller, coherent units. This skill assists in planning, grouping, and splitting changes to ensure atomic commits, making your Git history cleaner and reviews easier.

Core Features & Use Cases

  • Change Splitting Analysis: Helps identify how to logically split large changes into smaller commits, promoting clarity.
  • File Grouping: Suggests grouping related files for a single commit, ensuring logical cohesion.
  • Commit Sequence Planning: Guides the creation of a logical sequence of atomic commits, making the history easy to follow.
  • Use Case: A developer has made several unrelated changes in their working directory. They use this skill to analyze the changes, get suggestions on how to group files into atomic commits, and plan the sequence of commits, making their pull request much easier to review and reducing potential errors.

Quick Start

Use the atomic-commit skill to suggest atomic commits for the current staged changes.

Frequently Asked Questions about Atomic Commit Skill

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

FAQPage Schema
How do I split large changes into atomic commits?

Atomic commits represent single, logical changes that simplify reviews and debugging. This skill analyzes your staged changes, identifies file groups by scope and type, and generates a commit sequence plan showing how to split multi-file modifications into coherent units.

What's the best way to organize related files into commits?

File grouping for atomic commits ensures each commit addresses one concern—a feature, fix, docs update, or test. This skill examines your changes, detects dependencies between modifications, and recommends which files belong together to maintain logical cohesion.

How do I plan the sequence of commits in a pull request?

Commit sequencing matters for reviewability and bisectability. This skill constructs a dependency graph of your changes, applies topological ordering, and produces a concrete step-by-step plan showing the order to commit files so earlier commits don't depend on later ones.

Can I automate atomic commit planning for unrelated changes?

Yes. When you've made several unrelated modifications across features, fixes, and tests, this skill automates the analysis by extracting change types and scopes, grouping files logically, resolving dependencies, and delivering an interactive commit plan with scripts.

What's the difference between atomic commits and squashing changes?

Atomic commits preserve distinct logical units in history; squashing collapses all changes into one. Atomic commits make bisecting bugs easier and code reviews clearer because each commit explains one intent, whereas squashed history loses that granularity.

Do I need Git knowledge to use atomic commit planning?

Basic Git familiarity is helpful—understanding staging and branching. This skill handles the planning logic using Python and Bash tooling; you follow its recommendations to execute commits, so it bridges analysis and action without requiring deep Git internals knowledge.