skills.rest
thoreinstein
thoreinsteinCOMMUNITY
Explore all skills by this author →
GitHub

commit

Analyze git diffs to plan atomic commits with grouped files and messages.

5|2|Updated Dec 11, 2025
Search Tags:#git#planning#commit#staging#diff#version-control#atomic
One-click install
npx skills add https://github.com/thoreinstein/opencode-config --skill commit-thoreinstein
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/thoreinstein/opencode-config/tree/main/skill/commit
Command: npx skills add https://github.com/thoreinstein/opencode-config --skill commit-thoreinstein

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers convert a messy set of unstaged and partially staged changes into a clear sequence of small, logically grouped commits, reducing risk and improving history readability.

Core Features & Use Cases

  • Atomic grouping: automatically groups related changes into smallest independent commits.
  • File and hunk targeting: identifies which files or hunks to include in each commit.
  • Commit messaging: provides concise, descriptive commit messages for each group.
  • Dependency awareness: notes ordering constraints (e.g., a refactor must be committed before a dependent feature).
  • No-push policy: generates plan without performing any pushes.

Quick Start

  • Ensure you are in a Git repository with unstaged changes.
  • Run the commit skill with your current diff; it will output an atomic commit plan with grouped files, suggested messages, and any dependencies.

Frequently Asked Questions about commit

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

FAQPage Schema
How do I plan atomic git commits from a messy set of unstaged changes?▼

To plan atomic git commits from unstaged changes, you can use a skill that analyzes your uncommitted diffs and generates a structured plan grouping related files and hunks into independent commits with suggested messages.

What is the best way to split unstaged file changes into smaller independent commits?▼

The best way to split unstaged changes is by analyzing git status and git diff outputs to automatically group related files and hunks, ensuring each commit represents a single logical change with dependency-aware ordering.

Can I get suggested commit messages for grouped unstaged file changes?▼

Yes, you can get suggested commit messages for grouped unstaged changes by processing your current diff to generate a structured plan that includes concise, descriptive messages for each atomic group.

Does this git commit planning approach handle dependency ordering between staged groups?▼

Yes, this git commit planning approach handles dependency ordering by analyzing the uncommitted diff and noting ordering constraints, ensuring a required refactor is committed before any dependent feature changes.

Will executing an atomic commit plan automatically push my grouped changes to the remote repository?▼

No, executing an atomic commit plan will not automatically push your changes. The process operates under a strict no-push policy, generating only the structured plan without performing any remote pushes.

Related Skills

Explore More Software Engineering Skills→
FlexNetOSFlexNetOS

kb-status

Review Git repository status and display detailed uncommitted changes.

Official
Basic
pipemind-compipemind-com

git-commit-changes

Split uncommitted git working-tree changes into numbered atomic commits with conventional messages.

Official
Intermediate
luanluan
4

git-surgeon

Perform hunk-level Git operations including staging, unstaging, discarding, and commit splitting.

Community
Intermediate
aspiersaspiers
15

git-staging

Stage selective Git changes by applying crafted patches to the index.

Community
Intermediate