commit

Create atomic git commits using a three-pass workflow.

1|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/chriswickett/agentic-github --skill commit-chriswickett
Or copy as Structured Prompt for Agent
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.