git-master

Creates atomic git commits and analyzes repository history for changes and bugs.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/ssccio/cc-on-web-base --skill git-master-ssccio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: git-master
Source: https://github.com/ssccio/cc-on-web-base/tree/main/skills/git-master
Command: npx skills add https://github.com/ssccio/cc-on-web-base --skill git-master-ssccio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Git changes often get bundled into messy commits and risky rebases, making reviews harder and history harder to understand when something breaks.

Core Features & Use Cases

  • Atomic commit planning: Forces meaningful commit boundaries based on how many files and concerns are touched, reducing review risk and rollback complexity.
  • Style-aware commit generation: Guides commit messages using detected conventions from the last 30 commits (language, semantic prefixes, and cadence).
  • History recovery and forensic debugging: Provides targeted git log, grep, blame, and bisect workflows to answer when code or behavior was introduced.
  • Safer rebasing habits: Enforces rebase guardrails (never rebase main/master) and safer forcing behavior via force-with-lease plus stash-before-rebase.

Quick Start

Tell the AI to convert your current work into atomic commits, then identify the first commit that introduced a specific bug you provide.

Frequently Asked Questions about git-master

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

FAQPage Schema
How do I split messy git changes into atomic commits?

To split messy git changes into atomic commits, this Skill analyzes how many files and concerns are touched and forces meaningful commit boundaries based on thresholds. This reduces review risk and rollback complexity by separating changes by concern.

How do I find when a specific behavior was introduced in git history?

To find when a behavior was introduced in git history, this Skill provides targeted git log, grep, blame, and bisect workflows. These forensic debugging commands trace exactly when specific code symbols or behaviors were introduced across the repository.

How does style-aware commit message generation work?

Style-aware commit message generation works by detecting conventions from the last 30 commits, including language, semantic prefixes, and cadence. This ensures new commit messages match existing repository styles rather than requiring manual convention checks.

What is the safest way to rebase git branches without losing changes?

The safest way to rebase git branches involves enforcing rebase guardrails that never rebase main or master and using force-with-lease for safer forcing behavior. This Skill also automatically stashes changes before rebasing to prevent data loss.

Can I use git bisect to debug history and find the first commit that introduced a bug?

Yes, you can use git bisect to debug history and find the first commit that introduced a bug. This Skill supports targeted bisect commands alongside git log and blame workflows to reliably trace when specific code changes or bugs were introduced.

What are the limitations of automated commit splitting for large changes?

Automated commit splitting for large changes is limited by enforced commit-splitting thresholds based on how many files and concerns are touched. While this reduces review risk, changes spanning too many concerns may require manual intervention to define meaningful boundaries.