commit-work

Create well-scoped git commits with Conventional Commits messages.

Updated Nov 30, 2018
One-click install
npx skills add https://github.com/guygrigsby/dotfiles --skill commit-work-guygrigsby
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit-work
Source: https://github.com/guygrigsby/dotfiles/tree/main/opencode/skills/commit-work
Command: npx skills add https://github.com/guygrigsby/dotfiles --skill commit-work-guygrigsby

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Creating git commits that are easy to review and safe to merge by ensuring only the intended changes are included, dividing work into logical commits, and writing clear, conventional messages.

Core Features & Use Cases

  • Smart Commit Splitting enables splitting mixed changes into logical commits (feature vs refactor, frontend vs backend, tests vs production) for precise review.
  • Conventional Commits Format enforces a standard type and scope in commit messages to improve traceability and automation.
  • Safety & Quality Checks scans for secrets, debug logs, and unrelated formatting changes to prevent risky commits; supports patch staging for fine-grained control.
  • Patch Staging & Verification guides staging only what belongs in the next commit and verifying with diffs before finalizing.

Quick Start

Inspect the working tree, stage changes selectively with patch mode, craft conventional commit messages, and verify each commit before finishing.

Frequently Asked Questions about commit-work

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

FAQPage Schema
How do I split mixed changes into logical git commits?

Split mixed changes into logical git commits by using patch staging (-p) to selectively group related modifications. This separates features from refactors or tests from production code to produce precise, review-ready commits.

What are Conventional Commits and when do I need them?

Conventional Commits enforce a standard type and scope in git commit messages to improve traceability and automation. You need them when preparing review-ready commits that require clear, structured formatting for safe merging.

How do I prevent secrets and debug logs from being committed?

Prevent secrets and debug logs from being committed by running automated safety and quality checks before finalizing. These checks scan your staged changes to block risky commits containing sensitive data or unrelated formatting changes.

What's the best way to stage only specific lines for a git commit?

The best way to stage specific lines for a git commit is using patch staging (-p). This allows fine-grained control to guide staging only what belongs in the next commit and verifying with diffs before finishing.

Can I use patch staging to prepare commits for code review?

Yes, you can use patch staging to prepare commits for code review by polishing messages and dividing work into logical commits. This ensures only intended changes are included, making commits easy to review and safe to merge.

Why should I verify git diffs before finalizing a commit?

Verify git diffs before finalizing a commit to ensure only intended changes are included. This verification step prevents unrelated formatting changes and debug statements from slipping into your logical, review-ready commits.