Agent skill

Player-Facing Patch Notes

by Donchitos in Donchitos/Claude-Code-Game-Studios

Writes player-facing patch notes from git history and changelogs, filtering out framework and maintenance commits and rewriting developer wording for players.

MITAuto-check: notesDevelopment

Install Player-Facing Patch Notes

skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill patch-notes -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Donchitos/Claude-Code-Game-Studios patch-notes --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Donchitos/Claude-Code-Game-Studios.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/patch-notes .claude/skills/patch-notes && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
patch-notes
GitHub stars
26k
Token cost
~2.5k tokens
SKILL.md length
1,169 words
Files
1
Skills in repo
73
Repo updated
First seen
Licence
MIT

At a glance

Writes player-facing patch notes from git history and changelogs, filtering out framework and maintenance commits and rewriting developer wording for players.

  • Works in 7 steps: Parse Arguments → Gather Change Data → Categorize and Translate → …
  • Preparing release notes for a game update from the commit log
  • SKILL.md covers Provenance check — before…, Phase 1: Parse Arguments, Phase 2: Gather Change Data and Phase 2b: Detect Tone Guide…, plus 5 more sections
  • Calls git and bash

What it does

The skill turns recent commit history into patch notes that players can read. Before writing, it samples the log with `git log --oneline -20` and sorts every commit into gameplay work, framework or maintenance work, or unclear. Maintenance and unclear commits are left out of the notes, and the skill reports how many commits it used out of how many it saw.

If no commit counts as gameplay work, the skill stops with a message and the count. It also checks that the game commits name systems found in `design/` and the code root, to confirm the history belongs to this game. The core task is translation, so developer language becomes player communication. The automation mode in the project config decides how often the agent pauses to ask before writing.

When your agent uses it

  • Preparing release notes for a game update from the commit log
  • Turning a developer changelog into text players will understand
  • Separating gameplay changes from tooling commits before publishing notes

Example prompts

  • “Write patch notes for the next update from the commits since the last release.”
  • “Turn our CHANGELOG into player-friendly patch notes for the community post.”
  • “Draft patch notes but leave out the CI and tooling changes.”

Requirements

  • A git repository with commit history
  • Pre-approved tools (allowed-tools): Read, Glob, Grep, Write, Bash, Bash(bash "*/.claude/skills/patch-notes/../../hooks/yaml-helper.sh" resolve_config *)

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Parse Arguments
  2. Gather Change Data
  3. Categorize and Translate
  4. Generate Patch Notes
  5. Review Output
  6. Save Patch Notes
  7. Next Steps

What it can do on your machine

Read from SKILL.md and the folder at commit b21fa0f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Glob
    • Grep
    • Write
    • Bash
    • Bash(bash "*/.claude/skills/patch-notes/../../hooks/yaml-helper.sh" resolve_config *)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • bash

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Player-Facing Patch Notes loads about 2.5k tokens when it runs. Until then it costs about 32 tokens; SKILL.md has 1,169 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~32
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Glob, Grep, Write, Bash, Bash(bash "*/.claude/skills/patch-notes/../../hooks/yaml-helper.sh" r

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Donchitos/Claude-Code-Game-Studios at commit b21fa0f, republished under its MIT licence (© Donchitos). 1,169 words, ~2,483 tokens.

Download SKILL.mdSave it as .claude/skills/patch-notes/SKILL.md (or your agent's skills folder).
name
patch-notes
description
Player-facing patch notes from git history and changelogs. Translates developer language into player communication.
allowed-tools
Read, Glob, Grep, Write, Bash, Bash(bash "*/.claude/skills/patch-notes/../../hooks/yaml-helper.sh" resolve_config *)
argument-hint
[version] [--style brief|detailed|full]
user-invocable
true
model
sonnet

!bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys automation

Automation mode: Resolve modes.automation (project.local.yaml → project.yaml → default collaborative). Every AskUserQuestion call and every file write follows .claude/docs/automation-modes.md (collaborative asks always · guided major-only · autonomous logs and proceeds; automation_always_ask categories always prompt).

Provenance check — before reading any history

Confirm the history you are about to read belongs to THIS game. Run this before Phase 2 and stop if it fails.

  1. Sample the recent log: git log --oneline -20. If it is empty or git is unavailable, skip this check — there is nothing to classify, and Phase 2's no-changelog-data branch is the right stop.
  2. Classify every commit in the range, one at a time, into exactly one of:
    • Game — changes the game the player plays: mechanics, content, balance, art, audio, UI, a bug in any of those.
    • Framework / maintenance — changes CCGS itself or the project's tooling: subjects naming skills, hooks, agents, the test plan, CI, the framework's own docs. Excluded from player-facing notes, but not a reason to stop.
    • Unclear — treat as framework. A commit you cannot confidently place is not one to write player copy from.
  3. Then decide from the counts:
    • At least one Game commit → proceed, using only those. Say how many of how many you used, so the reader can see the filter ran.
    • Zero Game commits → stop, using the message below, and give the count (0 of how many) so the reader can see the filter ran.

Filter per commit; do not stop on a repo that merely contains maintenance work. Every project built on this framework accumulates commits touching hooks, CI and skills — the game repo is the framework repo. An earlier version of this check listed "subjects naming the framework, its skills, hooks, agents or test plan" as a hard STOP, which fires on virtually every real project and contradicted its own step 2 whenever a history was mostly the game's. The danger was never that such commits exist; it is that they get rendered as player-facing copy. Excluding them addresses that exactly, and a repo-level stop does not.

Corroborate before you proceed, cheaply: the Game commits should name systems that appear in design/ and the code root (src/, Assets/ or Source/). If they name a product those directories never mention, that is the real wrong-history signal — stop.

If no commit in the range is this game's, say so and stop:

"The git history in this repo does not appear to belong to [game]: 0 of the [N] recent commits are Game commits. The recent commits describe [what they actually describe]. I cannot generate release notes from it — point me at the right history, or supply the change list directly."

Verdict: BLOCKED — stop here without generating notes.

Why this is a hard stop, not a warning. This exact failure is real, not hypothetical: a batch of framework-internal commits produced player-facing copy reading "Fixed an issue where progress from your last session could be lost on launch" — a session-hook timeout rendered as a gameplay fix for a game with no save system. It was fluent, plausible, and entirely false. A reader cannot tell the difference; only this check can.


Phase 1: Parse Arguments

  • version: the release version to generate notes for (e.g., 1.2.0)
  • --style: output style — brief (bullet points), detailed (with context), full (with developer commentary). Default: detailed.

If no version is provided, ask the user before proceeding.


Phase 2: Gather Change Data

  • Read the internal changelog at production/releases/[version]/changelog.md if it exists
  • Also check docs/CHANGELOG.md for the relevant version entry
  • Run git log between the previous release tag and current tag/HEAD as a fallback
  • Read sprint retrospectives in production/sprints/ for context
  • Read any balance change documents in design/balance/
  • Read bug fix records from QA if available

If no changelog data is available (neither production/releases/[version]/changelog.md nor a docs/CHANGELOG.md entry for this version exists, and git log is empty or unavailable):

"No changelog data found for [version]. Run /changelog [version] first to generate the internal changelog, then re-run /patch-notes [version]."

Verdict: BLOCKED — stop here without generating notes.


Show full SKILL.md (504 more words)Show less

Phase 2b: Detect Tone Guide and Template

Tone guide detection — before drafting notes, check for writing style guidance:

  1. Check .claude/docs/technical-preferences.md for any "tone", "voice", or "style" fields or sections.
  2. Check docs/PATCH-NOTES-STYLE.md if it exists.
  3. Check design/community/tone-guide.md if it exists.
  4. If any source contains tone/voice/style instructions, extract them and apply them to the language and framing of the generated notes.
  5. If no tone guidance is found anywhere, default to: player-friendly, non-technical language; enthusiastic but not hyperbolic; focus on what the player experiences, not what the developer changed.

Template detection — check whether a patch notes template exists:

  1. Glob for docs/patch-notes-template.md and .claude/docs/templates/patch-notes-template.md.
  2. If found at either location, read it and use it as the output structure for Phase 4 instead of the built-in style templates (Brief / Detailed / Full). Fill in the template's sections with the categorized data, mapping each category to the template section that means the same (New Content → its new-features section, Bug Fixes → its fixes section); a category with no matching section goes under the closest one, never dropped. Keep the template's header and footer text as written. Say in the output which template was used — and, when --style was passed, that the template replaced it.
  3. If not found, use the built-in style templates as defined in Phase 4.

Phase 3: Categorize and Translate

Categorize all changes into player-facing categories:

  • New Content: new features, maps, characters, items, modes
  • Gameplay Changes: balance adjustments, mechanic changes, progression changes
  • Quality of Life: UI improvements, convenience features, accessibility
  • Bug Fixes: grouped by system (combat, UI, networking, etc.)
  • Performance: optimization improvements players might notice
  • Known Issues: transparency about unresolved problems

Translate developer language to player language:

  • "Refactored damage calculation pipeline" → "Improved hit detection accuracy"
  • "Fixed null reference in inventory manager" → "Fixed a crash when opening inventory"
  • "Reduced GC allocations in combat loop" → "Improved combat performance"
  • Remove purely internal changes that don't affect players
  • Preserve specific numbers for balance changes (damage: 50 → 45)

Phase 4: Generate Patch Notes

Brief Style
markdown
# Patch [Version] — [Title]

**New**
- [Feature 1]
- [Feature 2]

**Changes**
- [Balance/mechanic change with before → after values]

**Fixes**
- [Bug fix 1]
- [Bug fix 2]

**Known Issues**
- [Issue 1]
Detailed Style
markdown
# Patch [Version] — [Title]
*[Date]*

## Highlights
[1-2 sentence summary of the most exciting changes]

## New Content
### [Feature Name]
[2-3 sentences describing the feature and why players should be excited]

## Gameplay Changes
### Balance
| Change | Before | After | Reason |
| ---- | ---- | ---- | ---- |
| [Item/ability] | [old value] | [new value] | [brief rationale] |

### Mechanics
- **[Change]**: [explanation of what changed and why]

## Quality of Life
- [Improvement with context]

## Bug Fixes
### Combat
- Fixed [description of what players experienced]

### UI
- Fixed [description]

### Networking
- Fixed [description]

## Performance
- [Improvement players will notice]

## Known Issues
- [Issue and workaround if available]
Full Style

Includes everything from Detailed, plus:

markdown
## Developer Commentary
### [Topic]
> [Developer insight into a major change — why it was made, what was considered,
> what the team learned. Written in first-person team voice.]

Phase 5: Review Output

Check the generated notes for:

  • No internal jargon (replace technical terms with player-friendly language)
  • No references to internal systems, tickets, or sprint numbers
  • Balance changes include before/after values
  • Bug fixes describe the player experience, not the technical cause
  • Tone matches the game's voice (adjust formality based on game style)

Phase 6: Save Patch Notes

Present the completed patch notes to the user along with: a count of changes by category, and any internal changes that were excluded (for review).

Ask: "May I write these patch notes to docs/patch-notes/[version].md, and an archive copy to production/releases/[version]/patch-notes.md?"

If yes, write both files, creating the directories if needed. If no, write nothing.


Phase 7: Next Steps

Verdict: COMPLETE — patch notes generated and saved. (If the write was declined: Verdict: COMPLETE — patch notes generated and shown, not saved.)

  • Run /release-checklist to verify all other release gates are met before publishing.
  • Share the patch notes draft with the community-manager for tone review before posting publicly.

© Donchitos, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/patch-notes of Donchitos/Claude-Code-Game-Studios.

Open the folder on GitHubat commit b21fa0f

Compare with similar skills

Player-Facing Patch Notes next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Player-Facing Patch Notes compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Player-Facing Patch Notes this skillDonchitos/Claude-Code-Game-Studios26k—~2.5kAutomated safety check: NotesMIT
Release Bumpjamiepine/voicebox57k—~1.1kAutomated safety check: PassMIT
Git Workflow and Versioningaddyosmani/agent-skills102k2 repos~3.5kAutomated safety check: NotesMIT
Go-Redis Release Preparationredis/go-redis22k—~1.1kAutomated safety check: PassBSD-2-Clause
Hunk Release Workflowmodem-dev/hunk9.5k—~3.8kAutomated safety check: PassMIT
pybind11 Release Preparationpybind/pybind1118k—~1.7kAutomated safety check: PassCustom licence

Similar skills

  • Release Bump

    jamiepine/voicebox

    Ends a release cycle by moving the Unreleased changelog notes under a dated version heading, bumping version files with bumpversion and tagging the commit.

    57k GitHub stars~1.1k tokensUpdated today
    DevelopmentAuto-check passed
  • Git Workflow and Versioning

    addyosmani/agent-skills

    Sets git habits for every change: short-lived branches, atomic commits with descriptive messages, clean pull requests, plus versioning, tagging and changelogs for releases.

    102k GitHub starsUsed in 2 repos~3.5k tokens
    DevelopmentAuto-check: notes
  • Official

    Prepares a go-redis release locally: picks the next semver, gathers merged PRs, writes the RELEASE-NOTES entry and bumps versions, without publishing.

    22k GitHub stars~1.1k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Hunk Release Workflow

    modem-dev/hunk

    Maintainer workflow for preparing, publishing, verifying and curating Hunk releases, with confirmation gates before tags, publishes and public edits.

    9.5k GitHub stars~3.8k tokensUpdated today
    DevelopmentAuto-check passed
  • Opens the pybind11 release-preparation pull request: picking the release base, bumping the version in common.h and integrating the changelog, following docs/release.rst.

    18k GitHub stars~1.7k tokensUpdated today
    DevelopmentAuto-check passed
  • AionUi Version Bump

    iOfficeAI/AionUi

    Automates an AionUi release: checks the latest AionCore release and its artifacts, updates package.json, writes the changelog, opens a PR and tags the release.

    33k GitHub stars~2.1k tokensUpdated 28 days ago
    DevelopmentAuto-check passed

More from Donchitos/Claude-Code-Game-Studios

All 73 skills in this repo
  • Game Asset Audit

    Donchitos/Claude-Code-Game-Studios

    Audits game assets against naming conventions, file size budgets and format standards, and finds orphaned assets and missing references.

    26k GitHub stars~2k tokensUpdated 8 days ago
    Auto-check passed
  • Game Asset Spec Writer

    Donchitos/Claude-Code-Game-Studios

    Writes per-asset visual specs and AI image-generation prompts for a game's characters, enemies and screens, driven by the GDD, art bible and an entity inventory.

    26k GitHub stars~5k tokensUpdated 8 days ago
    Auto-check passed
  • Game Balance Check

    Donchitos/Claude-Code-Game-Studios

    Checks game data and formulas for balance outliers, broken progression, degenerate strategies and economy problems, and answers 'could not run' when the data is missing.

    26k GitHub stars~2.2k tokensUpdated 8 days ago
    Auto-check passed
  • Structured Bug Reports

    Donchitos/Claude-Code-Game-Studios

    Turns a description into a structured bug report, or scans code for likely bugs, then verifies and closes reports through four modes.

    26k GitHub stars~2.5k tokensUpdated 8 days ago
    Auto-check: notes
  • Bug Triage

    Donchitos/Claude-Code-Game-Studios

    Reviews the open bug backlog, separates severity from priority, assigns fixes to sprints and reports systemic trends, writing a dated triage file.

    26k GitHub stars~2.3k tokensUpdated 8 days ago
    Auto-check passed
  • Changelog Generator for Games

    Donchitos/Claude-Code-Game-Studios

    Generates an internal or player-facing changelog from git commits and sprint data, filtering out framework maintenance commits so that only work on the game itself reaches release copy.

    26k GitHub stars~2.5k tokensUpdated 8 days ago
    Auto-check: notes

Works with

Questions about Player-Facing Patch Notes

What does Player-Facing Patch Notes do?

Writes player-facing patch notes from git history and changelogs, filtering out framework and maintenance commits and rewriting developer wording for players. The skill turns recent commit history into patch notes that players can read. Before writing, it samples the log with `git log --oneline -20` and sorts every commit into gameplay work, framework or maintenance work, or unclear.

When should I use Player-Facing Patch Notes?

Player-Facing Patch Notes fits situations like: preparing release notes for a game update from the commit log; turning a developer changelog into text players will understand; separating gameplay changes from tooling commits before publishing notes.

How do I install Player-Facing Patch Notes in Claude Code?

Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill patch-notes -a claude-code`. Or copy the skill folder (.claude/skills/patch-notes in Donchitos/Claude-Code-Game-Studios) into .claude/skills/patch-notes in your project. Claude Code loads it when a task matches its description.

How do I install Player-Facing Patch Notes in Codex?

Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill patch-notes -a codex`. Or copy the skill folder (.claude/skills/patch-notes in Donchitos/Claude-Code-Game-Studios) into .agents/skills/patch-notes in your project. Codex loads it when a task matches its description.

Can I use Player-Facing Patch Notes in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Donchitos/Claude-Code-Game-Studios --skill patch-notes -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/patch-notes, .gemini/skills/patch-notes, .github/skills/patch-notes and .opencode/skills/patch-notes in your project.

What does Player-Facing Patch Notes need to run?

Going by SKILL.md and its folder, Player-Facing Patch Notes needs the command-line tools its instructions call (git and bash). Our summary lists: A git repository with commit history. Its frontmatter pre-approves these tools: Read, Glob, Grep, Write, Bash, Bash(bash "*/.claude/skills/patch-notes/../../hooks/yaml-helper.sh" resolve_config *).

Does Player-Facing Patch Notes access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Player-Facing Patch Notes safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Player-Facing Patch Notes use?

Player-Facing Patch Notes is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Player-Facing Patch Notes use?

About 2.5k tokens (SKILL.md is roughly 9.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Player-Facing Patch Notes?

Skills that share tags, products or a category with Player-Facing Patch Notes: Release Bump (jamiepine/voicebox, 57k stars), Git Workflow and Versioning (addyosmani/agent-skills, 102k stars), Go-Redis Release Preparation (redis/go-redis, 22k stars) and Hunk Release Workflow (modem-dev/hunk, 9.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Player-Facing Patch Notes?

Donchitos (a GitHub user) maintains it in Donchitos/Claude-Code-Game-Studios, which has 25,834 GitHub stars. The repository holds 73 skills in this directory. The repository was last updated on September 29, 2026.

Source: Donchitos/Claude-Code-Game-Studios on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.