← sources

I turned 6 months of Claude Code habits into 12 reusable skills. Here's the /commit one in full (steal it).

source: reddit (reddit:ClaudeAI)published 2026-09-30 14:10ingested 2026-10-01 02:38

retained text

Every new Claude Code session I was re-explaining the same things: how we write commits, that it must never `git add -A`, that it should check the staged diff for secrets first, that "misc changes" is not a commit message. So I started writing them down as skills (`.claude/skills/<name>/SKILL.md`) and after a few months I had a set I copy into every repo.

The structure that worked best, for every skill: **When to use** → **Steps** with the exact commands → **Output format** → **Guardrails** (what it must NOT do) → **Example invocation**. The Guardrails section made the biggest difference; Claude follows "never" lists remarkably well when they are explicit.

Here is the `/commit` skill, complete. Save it as `.claude/skills/commit/SKILL.md` in any repo and type `/commit`:

    ---
    name: commit
    description: Write and create a Conventional Commit from the staged diff. Use when the user says commit, commit this, save my work, write a commit message, or stage and commit.
    ---
    
    # /commit — Conventional Commit from the staged diff
    
    Turn whatever is staged into one well-scoped commit with a Conventional Commits
    message (`type(scope): summary`), a body that explains *why*, and no surprises.
    
    ## When to use
    
    - The user says "commit", "commit this", "save my work", "write a commit message".
    - After you finish a change and the user asked you to commit as part of the task.
    - NOT when the user only wants a message drafted (then skip step 6 and print it).
    
    Arguments: `/commit` uses the staged diff. `/commit all` stages tracked changes first.
    `/commit <hint>` uses the hint as guidance for the summary line (e.g. `/commit fix the retry bug`).
    
    ## Steps
    
    1. Inspect state before touching anything:
       ```bash
       git status --porcelain
       git diff --cached --stat
       git diff --cached
       ```
       If `$ARGUMENTS` contains `all`, run `git add -u` first (tracked files only; never `git add -A`).
       If nothing is staged and no `all` argument, stop and ask what to stage. Do not guess.
    
    2. Refuse to commit secrets. Scan the staged diff for these patterns and abort with a clear
       message if any match: `.env`, `id_rsa`, `*.pem`, `AKIA[0-9A-Z]{16}`, `sk-[A-Za-z0-9]{20,}`,
       `password\s*=\s*['"]`, `BEGIN (RSA|EC|OPENSSH) PRIVATE KEY`.
    
    3. Match the repo's existing style. Read the last 20 subjects:
       ```bash
       git log --oneline -20
       ```
       If the repo uses a scope convention (`feat(api):`), tickets (`ABC-123`), or emojis, follow it.
       Conventional Commits is the default only when the history is inconsistent or empty.
    
    4. Decide the type from the diff, not from the file names:
       | type | when |
       |---|---|
       | `feat` | new user-visible behaviour |
       | `fix` | corrects wrong behaviour |
       | `refactor` | same behaviour, better structure |
       | `perf` | measurable speed/memory win |
       | `test` | only tests changed |
       | `docs` | only docs/comments changed |
       | `build` / `ci` | build system, dependencies, pipelines |
       | `chore` | everything else (formatting, renames) |
    
       Scope = the module/package the diff mostly touches (one word, lowercase). Omit if the diff is cross-cutting.
    
    5. If the staged diff mixes unrelated changes (e.g. a bug fix plus a dependency bump), say so
       and propose splitting into two commits with `git add -p`. Only proceed as one commit if the user agrees.
    
    6. Write the message and commit using a heredoc so quoting is safe:
       ```bash
       git commit -m "$(cat <<'EOF'
       fix(retry): stop doubling the backoff on the first attempt
    
       The initial delay was multiplied before the first sleep, so the
       first retry waited 2x the configured base. Start the multiplier at 1.
    
       Closes #142
       EOF
       )"
       ```
       Add `BREAKING CHANGE:` in the footer and `!` after the type (`feat!:`) if a public API changed.
    
    7. Verify and report:
       ```bash
       git log -1 --stat
       ```
    
    ## Output format
    
    - Subject line: imperative mood, no trailing period, <= 72 chars (aim for 50).
    - Blank line, then a body of 1-4 sentences explaining the *why* and any non-obvious tradeoff.
      Skip the body for trivial changes (typo, formatting).
    - Footer: `Closes #N`, `Refs #N`, `BREAKING CHANGE: ...` when applicable.
    
    Print the final message to the user and the one-line `git log -1 --oneline` result.
    
    ## Guardrails
    
    - Never run `git add -A` or `git add .`; never stage files the user did not mention.
    - Never use `--no-verify`, `--amend`, or `--allow-empty` unless the user explicitly asks.
    - Never commit if the pre-commit hook fails; show the failure and stop.
    - Never invent ticket numbers. Only reference issues that appear in the branch name, the diff, or the user's words.
    - Never write "misc changes", "update", "wip", or "fix stuff" as the subject.
    - Do not mention yourself or an AI in the message unless the repo's history already does.
    
    ## Example invocation
    
    ```
    > /commit
    Staged: src/retry.py (+4 -2), tests/test_retry.py (+18 -0)
    Type: fix   Scope: retry
    
    fix(retry): stop doubling the backoff on the first attempt
    
    The initial delay was multiplied before the first sleep, so the first
    retry waited 2x the configured base. Start the multiplier at 1 and add
    a regression test for the first-attempt delay.
    
    [main 3f2a9c1] fix(retry): stop doubling the backoff on the first attempt
     2 files changed, 22 insertions(+), 2 deletions(-)
    ```

Things I learned making these:

* Put the trigger phrases in the frontmatter `description`. Claude picks the skill up automatically when you say "commit this" even without the slash.
* Steps must have commands, not intentions. "Check the staged diff" gets skipped; `git diff --cached` does not.
* A good Example invocation is worth more than three paragraphs of explanation: it fixes the output format.
* Pair skills with hooks for the things that must never happen. A hook that exits 2 on `.env` edits beats any instruction.

I packaged the full set (12 skills, 4 CLAUDE.md templates, 5 hooks with bash + PowerShell scripts, 4 workflow playbooks) as a $19 kit; link in the comments for anyone who wants the rest. Happy to answer questions about the skill format here either way.

document fetched 2026-10-01 00:24 · canonical https://reddit.com/r/ClaudeAI/comments/1wu5ytm/i_turned_6_months_of_claude_code_habits_into_12