semantic-git

Generate conventional commits with atomic staging and plain git commands.

Updated Mar 24, 2026
One-click install
npx skills add https://github.com/tkmh04/CoffeeHouse-Management-System --skill semantic-git-tkmh04
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: semantic-git
Source: https://github.com/tkmh04/CoffeeHouse-Management-System/tree/main/.agents/skills/semantic-git
Command: npx skills add https://github.com/tkmh04/CoffeeHouse-Management-System --skill semantic-git-tkmh04

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Conventional Git workflows often suffer from unclear or non-atomic commits, making history hard to review. This skill ensures atomic commits aligned with the conventional commits spec and provides plain git commands before execution for transparency and safety.

Core Features & Use Cases

  • Enforces atomic commits by grouping related changes together and prompting for confirmation before each commit.
  • Outputs explicit, plain git commands prior to execution, enabling safe manual review or integration with tooling like zagi.
  • Uses conventional commit types (feat, fix, docs, etc.) to standardize history across teams.

Quick Start

Provide the changes you want to commit and I will format them into an atomic conventional commit and show the exact git commands to run.

Frequently Asked Questions about semantic-git

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

FAQPage Schema
How do I create atomic conventional commits in git without manually staging files?

Atomic conventional commits group related changes and enforce standardized types like feat or fix. This skill formats your changes into an atomic commit and outputs the exact git commands to run for transparent execution.

What is atomic staging in git and how does it improve commit history?

Atomic staging groups related changes together into a single commit before execution. This approach keeps git history clean and reviewable by ensuring each commit represents one logical change, guided by conventional commit types like feat, fix, or docs.

Can I review the plain git commands before a conventional commit is applied?

Yes, you can review plain git commands before execution. The skill outputs explicit git commands for manual review and asks for user confirmation prior to applying any changes, ensuring safe integration with your workflow.

How do I enforce conventional commit types like feat and fix across my team?

Enforcing conventional commit types standardizes history by requiring prefixes like feat, fix, or docs. This skill guides commits with explicit commands and enforces these types during feature work, bug fixes, and documentation updates.

Does this git commit workflow work without external dependencies?

Yes, the workflow operates without external dependencies. It requires no additional libraries, using plain git commands and user confirmation to automate standardized commits safely within your existing environment.

When should I not use automated conventional commits for my changes?

You should avoid automated conventional commits when changes are unrelated and cannot be grouped atomically. The skill enforces atomic staging, so non-atomic or mixed-scope changes require manual separation before processing.