commit

Create atomic git commits using a three-pass workflow.

1|Updated Feb 7, 2026

Search Tags:#git #workflow #commit #coding-standards #atomic-commits #version-control #conventional-commits

Ready to run

npx skills add https://github.com/chriswickett/agentic-github --skill commit-chriswickett

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/chriswickett/agentic-github/tree/main/skills/commit
Command: npx skills add https://github.com/chriswickett/agentic-github --skill commit-chriswickett

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Create atomic git commits following a disciplined, three-pass workflow to ensure a clean, readable history.

Core Features & Use Cases

One-commit-per-change policy: Each commit represents a single logical improvement that can be reviewed and reverted independently.
Three-pass workflow: content pass, standards pass, and final review checks to ensure formatting, messaging, and integrity.
Consistent commit messaging: enforce conventional prefixes, capitalization, 72-character wrap, and avoidance of trailing punctuation.
Use Case: During feature development, bug fixes, or documentation updates to maintain a coherent project history.

Quick Start

Identify a single logical change and apply the three-pass commit workflow to generate an atomic, well-formatted commit.

Frequently Asked Questions about commit

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

FAQPage Schema

How do I create atomic git commits with clear, reviewable messages?▼

Create atomic git commits by applying a three-pass methodology: a content pass to isolate a single logical change, a standards pass to enforce conventional commit formatting, and a final review to validate atomicity and message quality.

What is the best way to enforce conventional commit formatting in my workflow?▼

Enforce conventional commit formatting by applying a standards pass that checks for conventional prefixes, correct capitalization, a 72-character line wrap, and the removal of trailing punctuation to ensure readable git history.

Why does my git history become difficult to review and revert?▼

Git history becomes difficult to review when commits bundle multiple logical changes. Adopting an atomic commit policy ensures each commit represents a single improvement, allowing precise reversibility and independent review.

How do I structure a git workflow to ensure one commit per logical change?▼

Structure your git workflow using a three-pass process: identify and stage a single logical change, apply conventional commit standards, and perform a final review to validate that the commit is truly atomic before finalizing.

Can I use this atomic commit workflow for documentation updates and bug fixes?▼

Yes, the atomic commit workflow applies across feature development, bug fixes, and documentation updates, maintaining a coherent project history by ensuring every change is independently auditable and revertible.

What are the limitations of using a three-pass methodology for version control?▼

The three-pass methodology requires strict discipline to isolate single logical changes, making it less suitable for rapid prototyping where bundled changes are preferred over a clean, auditable history and precise reversibility.