One-click install
npx skills add https://github.com/webdevcody/go-mailing-list --skill commit-webdevcody
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/webdevcody/go-mailing-list/tree/main/.claude/skills/commit
Command: npx skills add https://github.com/webdevcody/go-mailing-list --skill commit-webdevcody

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you turn a sprawling working tree into a readable, reviewer-friendly commit history where each commit is logically related and buildable, instead of one mega-commit.

Core Features & Use Cases

  • Inventories changes safely: inspects your working tree, diffs, and staging state so it can split changes consistently.
  • Groups files by relatedness: forms commit boundaries using heuristics like test+implementation pairs, rename+edit pairs, schema+reader coupling, and shared-module + first-consumer adjacency.
  • Orders commits for buildability: sorts groups so schema → backend → frontend (and dependencies before consumers) land in a bisectable sequence.
  • Applies staged, guarded commits: stages only the exact paths per group, verifies with git status and cached diffs, then commits without skipping hooks.

Quick Start

Tell the Skill to “commit these changes” and it will propose a multi-commit grouping, wait for approval, then apply the commits in an order that stays buildable.

Frequently Asked Questions about commit

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

FAQPage Schema
How do I split a large set of git changes into multiple logically grouped commits?

You can split messy git changes by inventorying staged and unstaged files, grouping them by relatedness heuristics like test and implementation pairs, and applying safe per-group staged commits in a dependency-aware topological order.

What is the best way to order schema, backend, and frontend commits for a bisectable history?

Ordering commits for a bisectable history requires sorting groups topologically by dependencies, ensuring schema changes land before backend updates, which land before frontend consumers, maintaining buildability at every commit step.

How does git bisect benefit from splitting a messy change into clean commits?

Git bisect benefits from clean commits because splitting a sprawling working tree into dependency-aware, buildable commits ensures each step in the history compiles independently, allowing bisect to isolate exact failure points accurately.

Can I commit refactors and feature slices separately without bypassing git hooks?

Yes, you can commit refactors and feature slices separately without bypassing git hooks by staging only the exact paths per group, verifying with git status and cached diffs, and committing safely without skipping hooks.

Does this approach to commit splitting work with both staged and unstaged file edits?

Yes, this commit splitting approach works with both staged and unstaged file edits by performing a complete inventory of your working tree, analyzing diffs, and safely staging the exact paths needed for each logically grouped commit.

What heuristics are used to group files when splitting a sprawling working tree?

Heuristics used to group files when splitting a working tree include matching test and implementation pairs, rename and edit pairs, schema and reader coupling, and shared-module and first-consumer adjacency to form logical commit boundaries.