Official agent skill

Go-Redis Release Preparation

by redis in redis/go-redis

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

OfficialBSD-2-ClauseAuto-check passedDevelopment

Install Go-Redis Release Preparation

skills CLI
$ npx skills add redis/go-redis --skill prepare-release -a claude-code

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

GitHub CLI
$ gh skill install redis/go-redis prepare-release --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/redis/go-redis.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/prepare-release .claude/skills/prepare-release && 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
prepare-release
GitHub stars
22k
Token cost
~1.1k tokens
SKILL.md length
442 words
Files
1
Skills in repo
5
Repo updated
First seen
Licence
BSD-2-Clause

At a glance

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

  • Works in 6 steps: Pick the next version → Find the last release and gather changes → Write the release notes → …
  • Cutting a new go-redis version
  • SKILL.md covers This skill never publishes, 1. Pick the next version, 2. Find the last release and… and 3. Write the release notes, plus 3 more sections
  • Calls git, gh and make

What it does

The skill stages everything for a release and stops before anything is published. It never runs scripts/tag.sh with the flag that creates and pushes tags, never pushes, and never commits unless the maintainer asks, so the deliverable is a reviewable diff of bumped versions plus a new RELEASE-NOTES.md entry. The next vX.Y.Z comes from version.go by semver: patch for bug fixes, minor for new features and major for breaking changes, with the level confirmed with you when it is ambiguous.

To gather changes it finds the last root tag, matching only root tags because the tag script also tags every public submodule, and then lists the commits and merged PRs since it. PRs are grouped into highlights, features, fixes, performance and testing or infrastructure, leaving out dependabot bumps, typo-only doc fixes and internal refactors with no user-facing effect. A new section goes at the top of RELEASE-NOTES.md following the repository's template exactly, opening with the release type and whether it is a drop-in upgrade.

The repository's bump script then rewrites the go-redis dependency version in the submodule go.mod files, and the dry run of scripts/tag.sh verifies the result. Tool use is limited to git describe and gh pr list.

When your agent uses it

  • Cutting a new go-redis version
  • Writing the RELEASE-NOTES.md entry for a release
  • Updating the go-redis dependency version in submodule go.mod files
  • Choosing the next semver from what merged since the last release

Example prompts

  • “Prepare the next go-redis release and tell me whether it should be a patch or a minor.”
  • “Write the RELEASE-NOTES.md entry from the PRs merged since the last tag.”
  • “Bump the submodule go.mod files to the new version and run the tag dry run.”

Requirements

  • Git and the GitHub CLI (gh)
  • A checkout of redis/go-redis
  • Pre-approved tools (allowed-tools): Bash(git describe:*), Bash(gh pr list:*)

Workflow steps

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

  1. Pick the next version
  2. Find the last release and gather changes
  3. Write the release notes
  4. Bump versions
  5. Verify (dry run only)
  6. Hand off

What it can do on your machine

Read from SKILL.md and the folder at commit 6f2b263. 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:

    • Bash(git describe:*)
    • Bash(gh pr list:*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh
    • make
    • go

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

  • Network

    No URLs in SKILL.md. Its commands use git and gh, 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

Go-Redis Release Preparation loads about 1.1k tokens when it runs. Until then it costs about 135 tokens; SKILL.md has 442 words of instructions outside code blocks.

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

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 passed

The automated check found no risky patterns in SKILL.md.

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 redis/go-redis at commit 6f2b263, republished under its BSD-2-Clause licence (© redis). 442 words, ~1,072 tokens.

Download SKILL.mdSave it as .claude/skills/prepare-release/SKILL.md (or your agent's skills folder).
name
prepare-release
description
Use when preparing a go-redis release — cutting a new version, bumping version.go, updating the go-redis dependency version in submodule go.mod files, or writing the RELEASE-NOTES.md entry for a new vX.Y.Z. Covers choosing the next semver, finding the last release and gathering merged PRs since then, the release-notes format and what to exclude, running scripts/release.sh to bump versions, and verifying with the scripts/tag.sh dry-run. Does NOT create tags, push, or commit — publishing stays a manual maintainer step.
allowed-tools
Bash(git describe:*), Bash(gh pr list:*)

Preparing a go-redis release

Stage everything for a release locally, then stop before anything is published.

This skill never publishes

  • Never run scripts/tag.sh ... -t — the -t flag creates and pushes git tags.
  • Never git push anything (no commits, no tags).
  • Never commit on the maintainer's behalf unless they explicitly ask.

The deliverable is a reviewable diff: bumped versions plus a new RELEASE-NOTES.md entry. A human reviews it and runs the publish step.

1. Pick the next version

The current version is the source of truth in version.go:

sh
grep 'return' version.go        # e.g. return "9.21.0"

Choose the next vX.Y.Z by semver, based on what shipped since the last release:

  • patch (Z) — bug fixes only; drop-in upgrade.
  • minor (Y) — new features, no breaking changes; drop-in upgrade.
  • major (X) — breaking changes.

Confirm the level with the user if the changeset is ambiguous.

2. Find the last release and gather changes

scripts/tag.sh also tags every public submodule (extra/redisotel/vX.Y.Z, …), so a naive git describe returns a submodule tag. Match the root tag only:

sh
LAST=$(git describe --tags --abbrev=0 --match 'v[0-9]*')   # e.g. v9.21.0
git log "$LAST"..HEAD --oneline
gh pr list --state merged --limit 100 \
  --json number,title,author,mergedAt,url --search "merged:>=<last-release-date>"

Categorize the PRs: highlights, new features, bug fixes, performance, testing/infrastructure. Exclude dependabot bumps, typo-only doc fixes, internal refactors with no user-facing effect, and dependabot[bot] from the contributor list.

3. Write the release notes

Prepend a new # X.Y.Z (YYYY-MM-DD) section to the top of RELEASE-NOTES.md (newest first; leave older entries untouched). Follow .github/RELEASE_NOTES_TEMPLATE.md exactly — section order, emoji headers, the ([#PR](url)) by [@user](url) link format, and the **Full Changelog** compare link ${LAST}...vX.Y.Z. Open the lead line with the release type and whether it is a drop-in upgrade, matching the existing entries.

That template carries the full "what to exclude" and formatting rules — read it, don't reinvent them. release-drafter separately auto-drafts a GitHub release from PR labels (.github/release-drafter-config.yml); RELEASE-NOTES.md is the curated, hand-written record and is the file you edit.

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

4. Bump versions

Run the repo's bump script. It rewrites the go-redis dependency version in every submodule go.mod, runs go mod tidy, and bumps version.go. It does not commit, push, or switch branches:

sh
TAG=vX.Y.Z ./scripts/release.sh

5. Verify (dry run only)

Run the tag script's dry run — it checks that version.go and every go.mod already match the tag, and prints the tags it would push. No -t:

sh
./scripts/tag.sh vX.Y.Z         # DRY RUN — must pass cleanly; never add -t here
make build
git diff --stat                 # review version.go, submodule go.mod, RELEASE-NOTES.md

Fix anything the dry run flags before handing off.

6. Hand off

Report that the release is staged and list the publish steps for the maintainer to run themselves (this skill does not do them):

  1. Review git diff, then commit (chore(release): vX.Y.Z — see the commit-style skill; no AI-attribution trailer).
  2. Open and merge the release PR.
  3. After merge, tag and push: ./scripts/tag.sh vX.Y.Z -t.
  4. release-drafter publishes the GitHub release; reconcile it with the RELEASE-NOTES.md entry if needed.

Stop after step 5. Do not commit, tag, or push.

© redis, BSD-2-Clause. 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/prepare-release of redis/go-redis.

Open the folder on GitHubat commit 6f2b263

Compare with similar skills

Go-Redis Release Preparation 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.

Go-Redis Release Preparation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Go-Redis Release Preparation this skillredis/go-redis22k—~1.1kAutomated safety check: PassBSD-2-Clause
Release Bumpjamiepine/voicebox57k—~1.1kAutomated safety check: PassMIT
Creating Description For Gh PRredis/jedis12k—~838Automated safety check: PassMIT
Hunk Release Workflowmodem-dev/hunk9.5k—~3.8kAutomated safety check: PassMIT
Worktrunk Release Workflowmax-sixty/worktrunk8.9k—~6.9kAutomated safety check: PassCustom licence
pybind11 Release Publicationpybind/pybind1118k—~2.5kAutomated 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
  • Official

    Generate a clear, concise GitHub PR title and description from the diff between two local git branches, and save it to prDescription.md in the repo root.

    12k GitHub stars~838 tokensUpdated today
    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
  • Worktrunk Release Workflow

    max-sixty/worktrunk

    Walks a maintainer through cutting a Worktrunk release: sync the release branch, pass two test gates, review the changes, then publish.

    8.9k GitHub stars~6.9k tokensUpdated today
    DevelopmentAuto-check passed
  • Walks a maintainer through publishing a pybind11 release after the preparation PR merges, with preflight checks, confirmations before each push and a GitHub release.

    18k GitHub stars~2.5k tokensUpdated today
    DevelopmentAuto-check passed
  • Obot Release Notes Drafter

    obot-platform/obot

    Drafts release notes for an upcoming Obot minor release and saves them as an unpublished GitHub draft release, never tagging or publishing.

    1.1k GitHub stars~4.5k tokensUpdated today
    DevelopmentAuto-check passed

More from redis/go-redis

  • Official

    Walks through adding a new Redis or Redis module command to the go-redis client, from fetching the spec and docs to the type, interface wiring, parsing and tests.

    22k GitHub stars~1.4k tokensUpdated yesterday
    Auto-check passed
  • Official

    Explains how to run go-redis tests: the Docker Compose stack, make targets, focusing a single Ginkgo spec, the e2e suite and the version environment variables.

    22k GitHub stars~786 tokensUpdated yesterday
    Auto-check passed
  • Official

    Keeps every reference to the redislabs client-libs-test image tag in sync across the Makefile, compose file, GitHub workflows and docs when a Redis test version changes.

    22k GitHub stars~1.5k tokensUpdated yesterday
    Auto-check passed
  • Official

    Sets the commit message and PR conventions for the go-redis repository: Conventional Commits, the repo's scope names, breaking-change syntax and no AI trailer.

    22k GitHub stars~429 tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Go-Redis Release Preparation

What does Go-Redis Release Preparation do?

Prepares a go-redis release locally: picks the next semver, gathers merged PRs, writes the RELEASE-NOTES entry and bumps versions, without publishing. The skill stages everything for a release and stops before anything is published.md entry.

When should I use Go-Redis Release Preparation?

Go-Redis Release Preparation fits situations like: cutting a new go-redis version; writing the RELEASE-NOTES.md entry for a release; updating the go-redis dependency version in submodule go.mod files; choosing the next semver from what merged since the last release.

How do I install Go-Redis Release Preparation in Claude Code?

Run `npx skills add redis/go-redis --skill prepare-release -a claude-code`. Or copy the skill folder (.claude/skills/prepare-release in redis/go-redis) into .claude/skills/prepare-release in your project. Claude Code loads it when a task matches its description.

How do I install Go-Redis Release Preparation in Codex?

Run `npx skills add redis/go-redis --skill prepare-release -a codex`. Or copy the skill folder (.claude/skills/prepare-release in redis/go-redis) into .agents/skills/prepare-release in your project. Codex loads it when a task matches its description.

Can I use Go-Redis Release Preparation 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 redis/go-redis --skill prepare-release -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/prepare-release, .gemini/skills/prepare-release, .github/skills/prepare-release and .opencode/skills/prepare-release in your project.

What does Go-Redis Release Preparation need to run?

Going by SKILL.md and its folder, Go-Redis Release Preparation needs the command-line tools its instructions call (git, gh, make and go). Our summary lists: Git and the GitHub CLI (gh); A checkout of redis/go-redis. Its frontmatter pre-approves these tools: Bash(git describe:*), Bash(gh pr list:*).

Does Go-Redis Release Preparation access the network?

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

Is Go-Redis Release Preparation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Go-Redis Release Preparation use?

Go-Redis Release Preparation is published under the BSD-2-Clause licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Go-Redis Release Preparation use?

About 1.1k tokens (SKILL.md is roughly 4.3k 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 Go-Redis Release Preparation?

Skills that share tags, products or a category with Go-Redis Release Preparation: Release Bump (jamiepine/voicebox, 57k stars), Creating Description For Gh PR (redis/jedis, 12k stars), Hunk Release Workflow (modem-dev/hunk, 9.5k stars) and Worktrunk Release Workflow (max-sixty/worktrunk, 8.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Go-Redis Release Preparation?

redis (a GitHub organization, an official publisher) maintains it in redis/go-redis, which has 22,257 GitHub stars. The repository holds 5 skills in this directory. The repository was last updated on October 6, 2026.

Source: redis/go-redis on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.