Stop Manually Bumping Versions Across 7 Files: claude-code-plugin-release Does It Right

The Trending Signal Is Real — But Let's Look Closer

80,000+ stars and nearly 3,000 gained in the last seven days puts claude-code-plugin-release firmly in "people are actually using this" territory on SkillsMP, not just "people starred it and forgot about it." That kind of week-over-week momentum usually means word got out in a Discord server or someone posted a workflow screenshot that resonated. I went and read the actual SKILL.md before writing this, so let me tell you what's actually going on under the hood — and where I'd pump the brakes.

What This Skill Actually Does

This is a release automation skill for Claude Code plugin authors. Specifically, it's built around the claude-mem project's own release workflow, extracted and packaged as a reusable skill.

The core problem it solves: when you ship a plugin that targets multiple runtimes (Claude Code, Codex, OpenClaw, npm via npx), you have version strings scattered across a bunch of manifest files. Miss one, and you've got a broken release — either npx claude-mem@X.Y.Z 404s, or your marketplace listing shows the wrong version, or your plugin manifest is out of sync with what's actually installed.

This skill gives Claude an explicit, ordered checklist to execute the full release pipeline:

1. Determine semver bump type (patch/minor/major)
2. Update version strings across all seven manifest files
3. Verify with git grep that nothing was missed
4. Run npm run build-and-sync
5. Commit, tag, push
6. npm publish
7. Create a GitHub release
8. Regenerate the changelog from GitHub's API
9. Send a Discord notification
10. Verify clean working tree

That's a real pipeline, not a toy.

Why This Matters

Most developers shipping plugins to multiple registries have some version of this problem. You write a script, it works for six months, then you add a new manifest file and forget to update the script. Or you're in a hurry and manually bump three of the seven files, push, and then spend 20 minutes debugging why npx is resolving an old version.

The gap this fills is making the release checklist part of the agent's context rather than living in a Notion doc nobody reads or a bash script that's half-commented-out. When Claude has this skill loaded, you can say "cut a patch release" and it will walk through every step with verification gates built in.

The git grep verification step is particularly smart. Before and after the version bump, Claude runs:

git grep -n "\"version\": \"<NEW>\""
git grep -n "\"version\": \"<OLD>\""

The first should return exactly seven hits. The second should return zero. That's a cheap, fast sanity check that catches the "I forgot to update plugin/.claude-plugin/plugin.json" class of mistakes before they become a broken release.

Key Capabilities Worth Highlighting

1. Seven-file version coverage with a verification gate The skill explicitly lists every file that carries a version string and tells Claude to verify coverage with git grep before and after editing. This is the kind of thing that's obvious in retrospect but easy to skip when you're manually running through a checklist at 11pm.

2. npm run build-and-sync over plain npm run build The skill specifically calls out not to use npm run build for release validation because it can leave the local marketplace and worker out of sync. That's a real footgun that someone clearly stepped on. The fact that it's documented here means you don't have to learn it the hard way.

3. The np escape hatch If you want to use np (the interactive npm publish tool) instead of the manual tag-push-publish sequence, the skill tells you exactly when that's safe (only if you haven't already created the tag manually) and when it'll blow up (if you have). That's honest documentation.

4. Changelog generation from GitHub API Instead of maintaining a changelog by hand, the workflow regenerates it from GitHub releases via node scripts/generate-changelog.js. This only works if your GitHub releases have good notes — which the skill front-loads by telling you to write release notes before starting. That's the right order of operations.

5. Clean tree enforcement The final step is git status with an explicit requirement that the working tree is clean. Claude won't consider the release done until everything is committed and pushed. This prevents the "oops I forgot to push the changelog" situation.

Who Should Install This

Install it if: - You're actively developing and shipping Claude Code or Codex plugins - You're the author or maintainer of claude-mem or a similar multi-manifest plugin project - You've already got the underlying scripts (npm run build-and-sync, npm run changelog:generate, npm run discord:notify) set up in your project - You want Claude to handle release mechanics so you can focus on writing good release notes

Don't install it if: - You're not shipping plugins — this skill is highly specific to the claude-mem project's infrastructure and won't generalize cleanly to an arbitrary npm package - You don't have the supporting scripts already in place. The skill assumes build-and-sync, changelog:generate, and discord:notify npm scripts exist. Without them, Claude will get halfway through the workflow and hit errors - You're looking for a general-purpose semver bump tool. This isn't that. It's a workflow codified from one specific project's release process

How to Install

Drop it in your project-level skills directory or your global Claude skills folder:

# Project-level (recommended for plugin repos)
mkdir -p .claude/skills
curl -o .claude/skills/claude-code-plugin-release.md \
  https://raw.githubusercontent.com/thedotmack/claude-mem/main/plugin/skills/version-bump/SKILL.md

# Or globally
mkdir -p ~/.claude/skills
# same curl, different destination

Then in Claude Code, reference it when you're ready to cut a release. You'll want to have your release notes drafted before invoking it — the skill tells you this upfront, and it's good advice.

Concerns and Limitations

This is not a generic skill. I want to be direct about this: the skill is the claude-mem project's own release workflow, packaged as a skill. The seven manifest paths are hardcoded to claude-mem's directory structure. The Discord notification step assumes a .env file lives at ~/Scripts/claude-mem/. If your project has a different structure, you'll need to fork and modify this before it's useful.

The Discord step is a footgun waiting to happen. The skill instructs Claude to cd ~/Scripts/claude-mem/ && npm run discord:notify vX.Y.Z — that's an absolute path to a directory that almost certainly doesn't exist on your machine. If you install this skill in a different project and don't read carefully, Claude will attempt this step and either fail silently or error out. It should probably be a conditional step or at minimum flagged as project-specific.

No rollback instructions. If npm publish succeeds but the GitHub release creation fails, or if the changelog generation errors out, the skill doesn't tell you how to recover. You're on your own to unpublish, delete the tag, etc. For a workflow that touches npm's immutable publish registry, that's a meaningful gap.

Assumes gh CLI is authenticated. The GitHub release step uses gh release create, which requires the GitHub CLI to be installed and authenticated. That's a reasonable assumption for most developers, but it's not documented as a prerequisite.

80k stars on a release automation skill is unusual. I'm not saying the star count is fake — claude-mem itself is a legitimately popular project — but release tooling skills don't typically go viral. The stars are probably for the parent claude-mem project and the skill is riding that momentum. Judge the skill on its merits, not the number.

Verdict

If you're a claude-mem contributor or you're building a similarly structured multi-manifest plugin, install this. It's a well-thought-out workflow that catches real mistakes with real verification steps. The git grep gates and the explicit ordering of operations reflect actual hard-won experience shipping plugin releases.

If you're hoping this is a general-purpose release automation skill you can drop into any project, you'll be disappointed. It's not. You'll spend more time adapting it than you would have just running the steps manually.

The honest summary: this is a great example of how to write a release workflow skill — specific, ordered, with verification gates and a clean-tree requirement. Use it as a template even if you don't use it directly.

SkillsMP page: https://skillsmp.com/skills/thedotmack-claude-mem-plugin-skills-version-bump-skill-md

GitHub source: https://github.com/thedotmack/claude-mem/tree/main/plugin/skills/version-bump