git-master

Manage Git operations with atomic commits, rebase, squash, and history search.

Updated Feb 21, 2026
One-click install
npx skills add https://github.com/stubbornstoneother/my-fastapi-full-stack --skill git-master-stubbornstoneother
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: git-master
Source: https://github.com/stubbornstoneother/my-fastapi-full-stack/tree/main/.agent/skills/git-master
Command: npx skills add https://github.com/stubbornstoneother/my-fastapi-full-stack --skill git-master-stubbornstoneother

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill streamlines complex Git operations, ensuring clean, atomic commits and efficient history management, preventing common pitfalls and improving code quality.

Core Features & Use Cases

  • Atomic Commits: Enforces the creation of multiple, focused commits for changes across different files or modules.
  • History Rewriting: Facilitates safe and effective rebasing, squashing, and cleanup of commit history.
  • Change Discovery: Enables powerful searching through commit history to find when and by whom specific changes were introduced.
  • Use Case: When you've made several unrelated changes, this Skill will help you break them down into individual, well-described commits instead of one large, unmanageable one.

Quick Start

Use the git-master skill to commit your staged changes following best practices for atomicity and clarity.

Frequently Asked Questions about git-master

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

FAQPage Schema
How do I split unrelated staged changes into atomic commits?

To create atomic commits, this Skill analyzes your staged changes and breaks them down into multiple, focused commits based on module boundaries and logical separation, ensuring each commit represents a single, clear change.

What is the best way to squash commits during a rebase?

Squashing commits during a rebase is managed by rewriting history to combine multiple commits into a single, cohesive entry, following best practices for commit granularity and dependency ordering to maintain a clean log.

How does git blame and bisect help with change discovery in commit history?

Git blame and bisect enable detailed change discovery by searching commit history to pinpoint exactly when and by whom specific lines were introduced or regressed, facilitating efficient debugging and history analysis.

Can I use this to manage conflict resolution across complex Git workflows?

Yes, this Skill manages conflict resolution across various Git workflows by guiding rebase and history rewriting operations, ensuring that merge conflicts are addressed while maintaining dependency ordering and commit clarity.

When do I need to rewrite Git history instead of adding new commits?

You need to rewrite Git history when cleaning up a messy commit log before sharing, using rebase and squash to consolidate unrelated changes into atomic, well-described commits that improve overall code quality.

Why should I enforce commit granularity for version control?

Enforcing commit granularity in version control prevents common pitfalls by ensuring changes are atomic and focused, which streamlines code review, simplifies debugging, and maintains a manageable project history.