Dev & Engineering release-managementchangelogsemvergithub-releasesmulti-languageversion-bumpgit

Universal Release Flow

Auto-detects version files and changelogs, then handles version bump, commit, tagging, and GitHub Releases for any project.

FollowSkills review · FSRS-2.0
Not recommended
51/ 100 5-point scale 2.6 / 5
1 2 3 4 5 6
1Trust13 / 25 · 2.6/5

The skill requests user confirmation before key operations (Step 8), supports --dry-run mode, and confines outputs to the designs/ directory and local preview server. There are some higher-privilege actions such as auto-committing, pushing, and creating GitHub Releases, but all require explicit confirmation. No obvious data exfiltration or overreach is evident. Deductions: user confirmation flow depends on the AskUserQuestion tool's availability and correct implementation; if missing, it falls back to plain-text prompts as instructed. There is no explicit instruction to check for sensitive data or credentials before publishing, and no clear rollback mechanism.

2Reliability8 / 20 · 2.0/5

Instructions are detailed and structured, but as a static review, key path reproduction cannot be verified. Multiple shell commands (e.g., git tag, git log, git diff, gh release) may fail due to environmental differences, yet there is limited handling and feedback for these failures. Some handling exists for abnormal inputs (e.g., no tags, no changes, no matching changelog section), but failure feedback is not detailed. Deductions: due to static review limits, full marks unreachable; no test suite verifies the skill's own workflow; error handling may be insufficient, relying mainly on shell command exit status rather than explicit condition checks.

3Adaptability10 / 15 · 3.3/5

The skill is clearly positioned as a universal release workflow supporting multiple project types and languages. Trigger phrases are clear (e.g., 'release', '发布'), suitable for Chinese users. Environment fit: most operations rely on local git and gh, but final push and GitHub Releases depend on external services. Deductions: boundary conditions are not well stated, e.g., behavior in complex projects or non-git environments is not specified; trigger conditions may be overly broad (e.g., 'push' might falsely trigger).

4Convention10 / 15 · 3.3/5

Documentation is well-layered with Quick Start, options table, detailed steps, configuration examples, dry-run example, and known limits (e.g., not rewriting public lightweight tags). Clear license (MIT) and maintenance by Jim Liu are noted. Deductions: no explicit version history or changelog for the skill itself; lacks installation/update instructions for the skill; missing FAQs and troubleshooting sections.

5Effectiveness6 / 15 · 2.0/5

Core tasks (version release and changelog generation) have detailed steps and clear output formats (e.g., changelog format, commit message format). As a static review, actual output usability cannot be verified. Deductions: no actual output samples or user feedback to prove effectiveness; relies on external dependencies (e.g., gh, git) that may be unavailable; generated multi-language changelog quality depends on model capability and may not be fully reliable.

6Verifiability4 / 10 · 2.0/5

There are some verifiable aspects such as config formats and command examples, but lack of actual execution evidence. Some tests exist (e.g., for gen-pptx), but those cover only parts of export, not the skill's core workflow. Deductions: due to static review, independent verification impossible; test coverage insufficient; no third-party execution evidence or user feedback.

Evidence confidence:Low Reviewed Aug 07, 2026 Reviewed revision 026d4ea012bd
Before you use it
  • The skill depends on gh command and GitHub services, which may be unreachable from mainland-China networks, limiting release functionality; consider clarifying offline/restricted network behavior.
  • Confirmation steps exist before auto-committing, pushing, and creating releases, but users may accidentally publish if not carefully reviewed; advise users to review commands before executing.
  • No malicious code found, but the skill allows automatic execution of git and gh commands, which could have irreversible effects on repositories; suggest backing up repositories or using in environments that support rollback.
Review evidence [1][2][3][4][5][6][7][8]
See the full review method →

What does this skill do, and when should you use it?

A universal release workflow skill for Node.js, Python, Rust, Claude plugins, and generic projects. It auto-detects the project's version file and changelogs, analyzes git history to decide the next semantic version, and generates multi-language changelogs (English, Chinese, Japanese, etc.). It supports grouped commits per module, annotated tags, GitHub Release publishing, historical release backfill, and a dry-run mode.

Scans for version files (package.json, pyproject.toml, Cargo.toml, marketplace.json, VERSION/version.txt) and changelog files (CHANGELOG*.md, etc.); analyzes commits since the last tag to categorize feat/fix/docs/perf changes; detects breaking changes; determines version bump based on flags or commit analysis; generates changelog entries in each detected language and appends third-party contributor attribution; groups changes by skill/module and commits each separately with conventional commit messages; updates version files and creates an annotated tag; optionally pushes to remote and creates/edits a GitHub Release; supports historical release backfill via --backfill-releases.

  1. A maintainer of a monorepo with multiple skills/modules who wants per-module commits and auto-updated READMEs on each release.
  2. A team maintaining changelogs in English, Chinese, and Japanese who wants all versions generated automatically in one run.
  3. A developer who needs to create GitHub Releases for existing git tags that were never published.
  4. Anyone using a local agent like Claude Code or Codex who wants to trigger a standardized release with a single natural-language command.

What are this skill's strengths and limitations?

Pros
  • Auto-detects project type with zero configuration for common ecosystems.
  • Built-in multi-language changelog generation (en, zh, ja, ko, de, fr, es) with contributor attribution.
  • Optional .releaserc.yml hooks let you delegate custom packaging/publishing while keeping the core flow generic.
  • Dry-run mode previews every change before execution.
  • Backfill mode helps migrate legacy projects by creating missing GitHub Releases.
Limitations
  • Requires GitHub CLI (gh) installed and authenticated for GitHub Release operations.
  • Only auto-detects a fixed set of project types; others need manual .releaserc.yml config.
  • Assumes conventional-commit-style history for accurate changelog categorization.
  • No automated test suite is documented; reliability depends on real-world usage.
  • Multi-language coverage is limited to predefined language codes; regional variants like zh-CN may need mapping.

How do you install this skill?

This skill lives at .claude/skills/release-skills/ inside the baoyu-design repository. You can install the whole collection via npx skills add JimLiu/baoyu-design (auto-detects your agent), or manually copy the .claude/skills/release-skills/ folder into your project's .claude/skills/. The collection is MIT-licensed and maintained by Jim Liu.

How do you use this skill?

In any Agent Skills–compatible client, just say ‘release’ or ‘发布’ to trigger the skill. For example, in Claude Code run /release-skills to start auto-detection. Optional flags: --dry-run for preview, --major/--minor/--patch to force a bump type, --backfill-releases to fill in missing GitHub Releases. The skill will ask for confirmation on version and publishing options.

How does this skill compare with similar options?

Compared to semantic-release (a popular open-source tool), this skill works as an Agent Skill that integrates with natural language interactions and supports multi-language changelogs and per-module grouping out of the box, but lacks semantic-release's extensive plugin ecosystem.

FAQ

What dependencies does this skill require?
It needs Git, GitHub CLI (gh) with authentication, and a shell environment. No specific programming runtime is required beyond what your agent provides.
Is there a safe preview mode?
Yes, run with `--dry-run` to see all planned changes without executing anything.
My project type isn’t in the supported list; what can I do?
Create a .releaserc.yml file in the project root to manually specify the version file, changelog files, and optional release hooks.
Can I customize the release process for my project?
Yes, use the release.hooks in .releaserc.yml (prepare_artifact and publish_artifact) to inject your own packaging/publishing steps.

More skills from this repository

All from JimLiu/baoyu-design

Related skills