PluginBench
Skill
Pass
Audit score 90

writing-changelogs

riekelt/technical-writer

Write clear, honest changelog entries and release notes following structured conventions.

What is writing-changelogs?

A skill for documenting shipped changes in changelogs, release notes, and handover summaries. Use it after completing meaningful work to record what changed, why it matters, and what users need to do about it. Enforces historical accuracy, user-visible impact, and honesty about known issues and deferred work.

  • Structure changelog entries with outcome-first bold leads, root cause, and fix details
  • Distinguish breaking changes, additions, fixes, removals, and deprecations with standard categories
  • Separate implemented, deployed, and verified states—never conflate them
  • Surface known issues, deferred items, and deliberate omissions as citable entry types
  • Generate handover summaries covering why the work exists, what shipped, review focus, verification status, caveats, and residual risks
  • Enforce present tense, active voice, and user-visible impact over implementation detail

How to install writing-changelogs

npx skills add https://github.com/riekelt/technical-writer --skill writing-changelogs
Prerequisites
  • The `technical-writing` skill (required background for hard rules, truth rules, and style conventions)
Claude Code
Cursor
Windsurf
Cline

How to use writing-changelogs

  1. 1.Identify the shipped change: feature, fix, removal, or deprecation
  2. 2.State the user-visible outcome in a bold lead (not the implementation detail)
  3. 3.Explain the root cause or context, then the fix, with exact names inline
  4. 4.Categorize under Added, Changed, Deprecated, Fixed, Removed, or Security
  5. 5.If breaking, lead with the breaking change and required migration action
  6. 6.For handover summaries, cover in order: why this work exists, what shipped, review focus, verification (with exact commands and results), honest caveats, residual risks, and state owed
  7. 7.Never rewrite or delete existing entries; only append new ones
  8. 8.Use ISO dates and group by version where versions exist

Use cases

Good for
  • Writing a changelog entry after shipping a feature or significant bug fix
  • Preparing release notes that translate changelog facts for end users
  • Summarizing completed work for handover to a reviewer or operator
  • Documenting breaking changes with required migration actions and links
  • Recording removals, deprecations, and deferred work to prevent re-litigation of decisions
Who it's for
  • Technical writers documenting product changes
  • Engineers shipping features or fixes who need to communicate impact
  • Release managers preparing user-facing release notes
  • Team leads handing off completed work to reviewers or operators

writing-changelogs FAQ

When should I invoke this skill?

Invoke after shipping a meaningful change (a feature, significant fix, or removal), when writing release notes, or when summarizing what shipped. Do NOT invoke for trivial edits (roughly three changed files or fewer) or to rewrite existing entries.

What is the difference between a changelog and release notes?

A changelog speaks to engineers and records all technical changes; release notes are the audience-facing cut of the same facts, translated for end users. Both must draw on the same sources and never contradict each other.

How do I document a breaking change?

Lead the entry with the breaking change above all categories, state the required migration action inline, and link to a migration guide if one exists. The bold lead must convey user-visible impact.

What are honesty conventions and why do they matter?

Honesty conventions surface known issues, deferred items, and deliberate omissions as citable entry types. Never mark anything implemented, deployed, or verified unless that exact action was completed and checked. This prevents re-litigation of decisions and makes the changelog trustworthy.

What should a handover summary include?

Cover in order: why the work exists, what shipped, where to point the review, verification status (exact commands and results), honest caveats and mistakes, residual risks and what NOT to do, and state owed (merged-not-pushed, migrations, ordered steps).

Full instructions (SKILL.md)

Source of truth, from riekelt/technical-writer.


name: writing-changelogs description: Use when writing a changelog entry, release notes, or a "what shipped" summary after completing work. Encodes the entry shape, the handover template, and the honesty conventions. Use after shipping meaningful work, even if the user just says "summarize what we did".

Writing changelogs

REQUIRED BACKGROUND: the technical-writing skill (hard rules, truth rules, style).

Overview

The changelog's subject is the change, not the current state; migration docs and release notes are the other document types with that subject. It is historical: entries are never rewritten, only appended.

When to invoke, and not

Invoke after shipping a meaningful change (a feature, a fix of real size, a removal), when writing release notes, or when summarizing what shipped. Do NOT invoke for trivial edits (roughly three changed files, or three commits), and never rewrite or delete existing entries.

Rules

  • One entry per shipped change, newest first, ISO dates, grouped by version where versions exist.
  • Standard categories where the file uses them: Added / Changed / Deprecated / Fixed / Removed / Security. A Deprecated entry carries the removal date and the replacement.
  • Breaking changes lead the entry, above the categories, each with the required migration action stated (and the migration guide linked when one exists).
  • User-visible impact over implementation detail.
  • Present tense, active voice, and no jargon the reader would not know.
  • Group related changes, and never duplicate an existing entry.
  • Record removals, not just additions.
  • Release notes are the audience-facing cut of the same facts: what changed, who it affects, what to do about it. The changelog speaks to engineers; release notes to users of the system. Both draw on the same sources and must never contradict each other.

Entry shape

Document-type exception: the bold leads required below override the shared ban on bold-lead bullets. The exception covers changelog outcomes and the named known-issue, deferred-item, and omission categories only. Repeated label-value bullets remain banned elsewhere.

Bold lead stating the outcome, then root cause, then the fix, with exact names inline:

- **Reference-to-video routing fixed.** The resolver only knew three operation
  kinds, so requests with reference media routed to image-to-video. A
  `hasReferenceMedia()` check now gives reference-to-video a higher-priority
  branch.

Fixed entries explain the failure mode, not the diff. The bold lead carries the user impact, which lets a reader triage a change list.

Honesty conventions

Three entry types make a changelog citable:

  • Known issues surfaced but not fixed in this change, named as such.
  • Deferred items still owed ("one deploy needed to restore the webhook key").
  • Deliberate omissions, described by category, so the same omission is not re-litigated or mistaken for an oversight.

Never mark anything implemented, deployed, or verified unless that exact action was completed and checked. Distinguish implemented (in the repo) from deployed (live) from externally verified.

Handover / completion summary

For handing finished work to a reviewer or operator, cover these sections in order:

  1. Why this work exists
  2. What shipped
  3. Where to point the review (the decisions a reviewer must understand before judging)
  4. Verification status: exact commands and their results, never a bare checkmark
  5. Honest caveats and things I got wrong
  6. Residual risks and what NOT to do
  7. State and what is owed (merged-not-pushed, migrations, ordered steps with the consequence of wrong ordering)