Skip to content
Skills Library
Programming · Writing

git-commit-message

/git-commit-message

Writing conventions for Git commit messages in slf4j-toys — content only, not staging or pushing. Use whenever composing a commit message: the Conventional Commits header format (type(scope): summary), body structure, commit types and scopes, test-coverage mention, and AI attribution trailer. For staging/push/force-push mechanics and when to commit, see `trunk-based-development`; for passing a multi-line message through PowerShell, see `powershell`.

Repository
slf4j-toys ↗
Licence
Apache-2.0
Last repository change
14.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
2
Deprecation

No signals detected. Repository changed on 14.07.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Writing conventions for Git commit messages in slf4j-toys — content only, not staging or pushing. Use whenever composing a commit message: the Conventional Commits header format (type(scope): summary), body structure, commit types and scopes, test-coverage mention, and AI attribution trailer. For staging/push/force-push mechanics and when to commit, see `trunk-based-development`; for passing a multi-line message through PowerShell, see `powershell`.

Original author description

Writing conventions for Git commit messages in slf4j-toys — content only, not staging or pushing. Use whenever composing a commit message: the Conventional Commits header format (type(scope): summary), body structure, commit types and scopes, test-coverage mention, and AI attribution trailer. For staging/push/force-push mechanics and when to commit, see `trunk-based-development`; for passing a multi-line message through PowerShell, see `powershell`.

How it works

  1. Format
  2. Commit Types
  3. Scopes
  4. AI attribution
  5. Complete example
  6. Related Documentation
Original SKILL.md headings · 80 lines, 598 words
SKILL.md preview
---
name: git-commit-message
description: 'Writing conventions for Git commit messages in slf4j-toys — content only, not staging or pushing. Use whenever composing a commit message: the Conventional Commits header format (type(scope): summary), body structure, commit types and scopes, test-coverage mention, and AI attribution trailer. For staging/push/force-push mechanics and when to commit, see `trunk-based-development`; for passing a multi-line message through PowerShell, see `powershell`.'
---

# Git Commit Message Guidelines for slf4j-toys

This skill covers only the *content* of a commit message — not how to stage, commit, or push (see `trunk-based-development`) and not PowerShell string mechanics for passing a multi-line `-m` argument (see `powershell`). A well-structured commit message lets someone reconstruct why a change was made from `git log` alone, without re-reading the diff.

## Format

Commit messages **must** follow [Conventional Commits](https://www.conventionalcommits.org/):

```
<type>(<scope>): <summary>

<detailed body explaining what changed and why>

<test coverage information>

Co-Authored-By: <Assistant Name> <Model> <contact address>
```

- **Header** — `<type>(<scope>): <summary>`, summary in imperative mood ("implement", not "implemented"). Keep it a single scannable line; there's no strict character cap enforced in this project (`type(scope):` prefixes routinely push real headers here past 70 characters), but tighten the wording if you're running long without adding meaning. See Types and Scopes below.
- **Body** — a high-level paragraph of what changed and why, then a `Changes:` bullet list of technical changes. Group related changes, include quantitative detail ("86 test cases", "4 tests updated"), name specific classes/methods for traceability. Wrap body text at 72 characters.
- **Test coverage line** — state what was actually run and its result (e.g., "All 1710 Meter tests pass, confirming backward compatibility"). Don't write this from assumption — run the relevant tier from `run-test` first.
- **Attribution** — required on every AI-generated commit; see AI attribution below.
- **Scope discipline** — one concern per commit. Split unrelated changes into separate commits rather than bundling them.

## Commit Types

| Type | When to use |
|---|---|
| `feat` | New functionality, capability, or API |
| `fix` | Fixing a defect or incorrect behavior |
| `refactor` | Restructuring code without changing behavior |
| `perf` | Optimizing performance or resource usage |
| `test` | Adding/updating tests, no production code change |
| `docs` | Documentation, comments, README |
| `style` | Formatting/whitespace, no logic change |
| `chore` | Build scripts, dependencies, tooling |
| `ci` | GitHub Actions, build pipelines, automation |
| `revert` | Undoing a previous commit |

## Scopes

Common scopes in this project: `meter`, `watcher`, `reporter`, `logger`, `test`, `build`, `ci`.

## AI attribution

Name the actual assistant and model that generated the commit in the trailer shown in Format above — not a fixed placeholder tool name. For Claude Code, that's the harness default: `Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>`. If the commit is generated by GitHub Copilot specifically, follow `.github/copilot-instructions.md`'s override instead (`Co-authored-by: GitHub Copilot using <model name>`). Apply the same convention consistently to any PR description opened for this commit (see `git-pull-request`).

## Complete example

```
feat(meter): implement idempotent termination behavior

Meter termination methods (ok, reject, fail) now properly handle repeated
termination attempts by preserving the first termination state.

Changes:
- MeterValidator.validateStopPrecondition() now returns boolean instead of void
  - Returns false when meter already stopped (blocks re-termination)
  - Returns true otherwise (allows termination with warnings)
- Meter.commonOk(), reject(), fail() methods now check validation result
  - Early return when meter already stopped, preserving first termination
- Updated 86 test cases to verify idempotent behavior
  - MeterValidatorTest: 4 tests updated to capture boolean return
  - MeterLogBugTest: 6 tests updated for exception handling

All 1710 Meter tests pass, confirming backward compatibility.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
```

## Related Documentation

- `git-pull-request` skill — PR title/description conventions for the same change
- `trunk-based-development` skill — staging, pushing, force-push rules, and when to commit
- `powershell` skill — passing multi-line commit messages through PowerShell
- [Conventional Commits Specification](https://www.conventionalcommits.org/)
- [AGENTS.md](../../../AGENTS.md) — project AI agent guidelines
- [.github/copilot-instructions.md](../../../.github/copilot-instructions.md) — AI attribution standards

Versions

RepositoryScoreLicence
This page · useful-toys/slf4j-toys100Apache-2.0
FrancoStino/opencode-skills-collection100MIT
alapha888/agent-skills-en100MIT

Database snapshot: 13.11.2026 · package version fc0d3c557998 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100commit-message
    Generate conventional commit messages - use when creating commits, writing commit messages, or asking for git commit help
  • 100git-commit
    Guide for Git commit messages and pushing code. Use when user says "commit", "push code", "push to git", "save changes to git", "git add and commit", "commit and push", or needs help writing commit messages following Conventional Commits.
  • 90Conventional Commits
    This skill should be used when the user asks to 'write commit message', 'create conventional commit', 'format git commit', 'follow commit conventions', 'structure commit message'. Provides Conventional Commits patterns for consistent, machine-readable commit messages.
  • 100git-commit
    Guide for creating git commits in this repository: conventional commit format, allowed types, and branch naming conventions. Use when staging changes and writing a commit message, creating a branch, or naming a branch. Trigger on: "commit", "create a commit", "git commit",…
  • 100git-commit-workflow
    Conventional commit format, staging, and message conventions. Use when writing commit messages, staging files, grouping changes, or auto-detecting linked issues.
  • 100write-conventional-commit
    Create Git commit messages that conform to Conventional Commits 1.0.0, including type/scope/description format, optional body, trailer-style footers, and explicit BREAKING CHANGE signaling. Use when users ask to draft commit messages, commit current changes, rewrite a commit…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.