Commit Work
When & Why to Use This Skill
The commit-work skill is designed to automate and optimize the Git version control workflow. It assists developers in creating high-quality, logically scoped commits by reviewing staged changes, splitting complex updates into manageable parts, and drafting professional messages following the Conventional Commits standard. This ensures a clean project history, simplifies the code review process, and prevents the accidental inclusion of sensitive data or debug logs.
Use Cases
- Scenario 1: Splitting a large feature update into multiple logical commits (e.g., separating backend logic from frontend UI changes) to facilitate easier peer reviews.
- Scenario 2: Enforcing team-wide standards by automatically generating commit messages that follow the Conventional Commits format (feat, fix, chore, etc.).
- Scenario 3: Cleaning up a messy working directory using patch staging to selectively commit specific code hunks while leaving unrelated experimental code unstaged.
- Scenario 4: Performing a final sanity check before pushing to ensure no secrets, API tokens, or 'console.log' statements are included in the commit.
- Scenario 5: Improving repository maintainability by providing clear 'what' and 'why' descriptions for every change, making it easier to track regressions in the future.
| name | commit-work |
|---|---|
| description | "Create high-quality git commits: review/stage intended changes, split into logical commits, and write clear commit messages (including Conventional Commits). Use when the user asks to commit, craft a commit message, stage changes, or split work into multiple commits." |
Commit work
Goal
Make commits that are easy to review and safe to ship:
- only intended changes are included
- commits are logically scoped (split when needed)
- commit messages describe what changed and why
Inputs to ask for (if missing)
- Single commit or multiple commits? (If unsure: default to multiple small commits when there are unrelated changes.)
- Commit style: Conventional Commits are required.
- Any rules: max subject length, required scopes.
Workflow (checklist)
- Inspect the working tree before staging
git statusgit diff(unstaged)- If many changes:
git diff --stat
- Decide commit boundaries (split if needed)
- Split by: feature vs refactor, backend vs frontend, formatting vs logic, tests vs prod code, dependency bumps vs behavior changes.
- If changes are mixed in one file, plan to use patch staging.
- Stage only what belongs in the next commit
- Prefer patch staging for mixed changes:
git add -p - To unstage a hunk/file:
git restore --staged -porgit restore --staged <path>
- Prefer patch staging for mixed changes:
- Review what will actually be committed
git diff --cached- Sanity checks:
- no secrets or tokens
- no accidental debug logging
- no unrelated formatting churn
- Describe the staged change in 1-2 sentences (before writing the message)
- "What changed?" + "Why?"
- If you cannot describe it cleanly, the commit is probably too big or mixed; go back to step 2.
- Write the commit message
- Use Conventional Commits (required):
type(scope): short summary- blank line
- body (what/why, not implementation diary)
- footer (BREAKING CHANGE) if needed
- Prefer an editor for multi-line messages:
git commit -v - Use
references/commit-message-template.mdif helpful.
- Use Conventional Commits (required):
- Run the smallest relevant verification
- Run the repo's fastest meaningful check (unit tests, lint, or build) before moving on.
- Repeat for the next commit until the working tree is clean
Deliverable
Provide:
- the final commit message(s)
- a short summary per commit (what/why)
- the commands used to stage/review (at minimum:
git diff --cached, plus any tests run)