Index of every page on this site: llms.txt
All skills
davila7 avatar

/commit-smart

@053feb2
Run it yourself

Analyze staged/unstaged changes and create semantic conventional commits with context about WHY, not just WHAT. Auto-detects commit type and scope from the diff. Supports optional type/scope arguments. Usage - /commit-smart, /commit-smart fix, /commit-smart refactor api

Use this Skill: https://skilld.dev/gh/davila7/claude-code-templates/commit-smart

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈71 tokens for metadata: the name and description. ≈743 when used: this file.

Description uses 3.6% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈285 characters, or 3.6%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Smart Commit

Create meaningful conventional commits by analyzing your actual changes.

Workflow

Step 1: Assess the working tree

Run these commands to understand the current state:

git status
git diff --stat
git diff --cached --stat

Step 2: Handle unstaged changes

If nothing is staged (git diff --cached is empty):

  1. Show the user what files have changed
  2. Suggest what to stage based on logical grouping (e.g., "these 3 files are all related to the auth refactor")
  3. Ask if they want to stage all, or select specific files
  4. Stage the approved files with git add <files>

If changes are already staged, proceed to analysis.

Step 3: Analyze the diff

Read the full staged diff:

git diff --cached

Determine the commit type from the changes:

Signal Type
New files with new functionality feat
New test files or test additions test
Changes to existing logic fixing incorrect behavior fix
Structural changes without behavior change refactor
package.json, tsconfig, CI config changes chore
Build/bundler config changes build
README, docs, comments only docs
Formatting, whitespace, semicolons only style
Performance improvements perf

Determine the scope from the primary directory or module affected:

  • src/api/ -> api
  • src/components/auth/ -> auth
  • tests/ -> tests
  • Root config files -> omit scope
  • Multiple unrelated areas -> omit scope

Step 4: Check for user overrides

If the user provided arguments via $ARGUMENTS:

  • Single word (e.g., fix) -> use as commit type
  • Two words (e.g., refactor api) -> use as type and scope
  • Otherwise -> use auto-detected values

Step 5: Compose the commit message

Format: type(scope): imperative short description

Rules:

  • Subject line max 72 characters
  • Use imperative mood ("add", "fix", "refactor", not "added", "fixes")
  • Don't end with a period
  • Body explains WHY this change was made, not what changed (the diff shows what)
  • If changes are trivial (typo fix, formatting), skip the body

Example:

feat(auth): add JWT refresh token rotation

Tokens were expiring mid-session for users with slow connections.
Rotating refresh tokens extends the session without compromising
security, since each refresh token can only be used once.

Step 6: Confirm and commit

Show the user the proposed commit message and ask for confirmation.

If confirmed, run:

git commit -m "<message>"

Then verify with:

git log --oneline -1

Show the committed hash and message.

Tips

  • Run after completing a logical unit of work, not after every file change
  • If the diff is too large for one commit, suggest splitting into multiple commits
  • For breaking changes, add ! after the scope: feat(api)!: change response format
  • The body should answer "if someone reads this commit in 6 months, will they understand WHY?"

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning1mo4 checks · Risk SAFE
  • Gen Agent Trust Hub1mo

    The skill facilitates the creation of semantic git commits by analyzing repository changes. It uses standard git commands to assess the working tree, stage files, and generate commit messages based on logical diff analysis. No malicious behaviors or unauthorized access patterns were detected.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

  • Runlayer8mo

    1/1 file flagged

Signed by skilld at 053feb2. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 9 months ago

README badge

README badge for davila7/claude-code-templates/commit-smart