Skip to main content
skill CX Codex

Release · schpet — Claude Code skill: what it does, how to install

Release is a Claude Code skill that reviews changes, updates the changelog, and publishes a version. It activates for requests to prepare or create a release.

ISC 3,900 installs ★ 1,051 updated 2026-11-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add schpet/linear-cli --skill release -a claude-code
Open on GitHub

What Release does

Release runs a release workflow from the commits after the last tag through the final push. It filters changes for the changelog, recommends a SemVer increment, shows the Unreleased section for approval, then runs changelog release after confirmation.

The just tag recipe runs quality checks, writes the changelog version to Cargo.toml with svbump, refreshes Cargo.lock, creates a commit and tag with jj, and pushes the bookmark and tags. The recipe stops on the first failure. Version bumping cannot run without the installed svbump tool.

The workflow requires the changelog skill, installed svbump, jj, and just. After a successful release, it checks the GitHub tag and .github/workflows/release.yml, which builds binaries and publishes the Homebrew formula and npm package.

What it helps with

  • review commits made since the last release
  • turn user-facing changes into changelog entries
  • choose the correct SemVer increment
  • run release quality checks before tagging
  • push the bookmark and release tags

Example prompts for the agent

  • Prepare a release by reviewing commits after the latest tag and updating the changelog.
  • Show the Unreleased section, recommend a SemVer bump, and wait for my approval.
  • After I confirm, run changelog release and just tag.

How to install Release

1Skills CLI (Vercel)

npx skills add schpet/linear-cli --skill release -a claude-code

2Manually: put the files in place

~/.claude/skills/release/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/release/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about Release

How do I install Release in Claude Code?

Run npx skills add schpet/linear-cli --skill release -a claude-code; the skill file is then available at ~/.claude/skills/release/SKILL.md.

What does Release do?

It reviews commits after the previous tag, turns user-facing changes into changelog entries, recommends a SemVer bump, and after approval runs checks, tagging, and the release push.

What does Release need to work?

It requires the changelog skill, an installed svbump, plus jj and just. Publishing uses jj git push --bookmark main and git push origin --tags.

Source text

SKILL.md · ISC
---
name: Release
description: This skill should be used when the user asks to "make a release", "create a release", "cut a release", "release a new version", "publish a release", or mentions preparing for release. Provides comprehensive workflow for reviewing changes, updating changelog, determining semver bump, and publishing.
version: 0.1.0
---

# Release Workflow

This skill provides a systematic workflow for creating and publishing releases for the linear-cli project. It handles changelog management, version bumping, testing, and tagging.

## When to Use

Use this skill when preparing to release a new version of linear-cli. The workflow ensures all changes are documented, tests pass, and versions are properly tagged before publishing.

## Prerequisites

Ensure the following tools are available:

- `changelog` skill for changelog management
- `svbump` for version bumping (installed)
- `jj` for version control operations
- `just` for running the release tasks

## Release Workflow

### Step 1: Review Commits Since Last Release

Determine the commits that have been made since the last release:

```bash
jj log --ignore-working-copy --git -r 'tags()..@' --no-graph
```

This shows all commits from the most recent tag to the current commit.

### Step 2: Add Changelog Entries

For each commit identified above, evaluate whether it warrants a changelog entry. Focus on user-facing changes:

**Include in changelog:**

- New features
- Bug fixes
- Breaking changes
- Significant improvements
- Deprecations

**Exclude from changelog:**

- Internal refactoring without user impact
- Documentation-only changes
- Build/CI configuration changes
- Chore commits (unless significant)

Use the changelog CLI to add entries. Use `--attribute-pr` with the commit SHA to automatically look up the associated PR and add attribution, excluding `schpet` and `schpetbot`:

```bash
changelog add --type <type> "<description>" --attribute-pr <commit-sha> --exclude-users schpet,schpetbot
```

Omit `--attribute-pr` for commits without an associated PR or when attribution isn't relevant.

Types match Keep a Changelog categories:

- `added` - New features
- `changed` - Changes in existing functionality
- `deprecated` - Soon-to-be removed features
- `removed` - Removed features
- `fixed` - Bug fixes
- `security` - Security improvements

### Step 3: Verify Changelog with User

After adding all relevant changelog entries, show the unreleased section of CHANGELOG.md to the user and ask them to review it:

1. Read the CHANGELOG.md file
2. Show the `[Unreleased]` section
3. Ask: "Please review these changelog entries. Are there any changes needed before release?"
4. Make any requested adjustments

### Step 4: Determine Semver Bump

Based on the types of changes in the changelog, determine and recommend the appropriate semantic version bump:

**Major (X.0.0):**

- Breaking changes
- Removed features
- Significant API changes

**Minor (0.X.0):**

- New features (added)
- Deprecations
- Backward-compatible functionality additions

**Patch (0.0.X):**

- Bug fixes
- Security fixes
- Minor improvements with no new features

Present the recommendation to the user:

```
Based on the changelog entries, I recommend a <MAJOR/MINOR/PATCH> version bump because:
- [reason 1]
- [reason 2]

Current version: <current>
Proposed version: <proposed>

Should I proceed with this version bump?
```

Wait for user confirmation before proceeding.

### Step 5: Run Changelog Release

Once the user confirms the version bump, run the changelog release command with the appropriate semver level:

```bash
changelog release <major|minor|patch>
```

This updates CHANGELOG.md, converting the Unreleased section to a versioned release.

### Step 6: Execute Tag Process

After the changelog is released, run the tag recipe:

```bash
just tag
```

It does the whole release in order, stopping at the first failure:

1. **Quality checks** (`just check`): `cargo fmt --all --check`, `cargo clippy --locked --workspace --all-targets -- -D warnings`, and `cargo test --locked --workspace`
2. **Version bump:** writes the latest changelog version to `workspace.package.version` in `Cargo.toml` with `svbump`, then refreshes `Cargo.lock` with `cargo update --workspace`
3. **Commit and tag:** `jj commit -m "chore: Release linear-cli version <version>"`, then moves the `main` bookmark and sets the `v<version>` tag on that commit (`@-`)
4. **Push:** `jj git push --bookmark main`, then `git push origin --tags`

When it finishes it prints `released v<version>`.

## Error Handling

If any step fails:

- **Quality checks fail:** Fix the issues before continuing. Do not proceed with release if tests fail or linting errors exist.
- **Version bump fails:** Verify the version format and files exist.
- **Push fails:** Check authentication and remote access.

Always stop and report errors clearly. Never continue the release process if a critical step fails.

## Important Notes

- The justfile `tag` recipe runs every step above; there is no need to run them by hand
- Use `jj` for all version control operations (per the project AGENTS.md)
- Always use `--ignore-working-copy` for read-only jj operations
- The workflow creates a commit on the parent (@-) and then creates a new working commit
- Both `jj git push` and `git push origin --tags` are needed (jj for bookmark, git for tags)

## Post-Release

After successful release:

1. Verify the tag appears on GitHub
2. Check that the GitHub Actions release workflow (`.github/workflows/release.yml`) builds the binaries and publishes the Homebrew formula and npm package
3. Confirm the new version is published

## Reference

See the `tag` recipe in the `justfile` for the implementation.

© schpet · ISC · schpet/linear-cli

Similar skills

All skills for Git and GitHub →

Release by other authors comes first.

release tobi A skill for Claude Code, Codex, Cursor and other IDE agents that manages project releases: validates CHANGELOG.md, updates dependencies, installs git hooks and cuts releases on command. Runs with /release 1.0.5 or /release patch. CX Codex +1 2,200installs release Yeachan-Heo A repo-aware skill that discovers release rules from CI files, caches them in .omc/RELEASE_RULE.md, and guides releases. Helpful when preparing tags and version bumps. CX Codex +1 904installs release different-ai Cuts an OpenWork release from a git tag through GitHub Actions, with no commits to the repo. Checks open fix PRs before tagging and covers reruns after a failure. CX Codex +1 122installs release toss Automates project releases by verifying git status, bumping versions in package files, generating changelog entries, and tagging commits. CX Codex +1 208installs release cyrusagents This skill walks a Cyrus CLI release through trusted publishing: prepare, verify, publish, finish. Useful when a version has to ship without touching packages by hand. CX Codex +1 870installs release-skills JimLiu Automates release workflows, conventional commit parsing, and version bumps for Node.js, Python, or Rust. Builds changelogs and creates GitHub Releases. CX Codex +1 26,100installs release-manager borghei release-manager — a skill for Claude Code, Codex, Cursor, Copilot and Gemini CLI that turns git log output or a JSON plan into a changelog, a SemVer bump and a release readiness score. Run it before every release or hotfix. CX Codex +1 132installs release-bumper PaulRBerg release-bumper — a skill for Claude Code that automates package releases. It calculates semver bumps, compiles changelog entries, commits changes, and creates annotated tags. CX Codex +1 105installs team-release sametcelikbicak team-release is a Claude Code skill that turns a release into ordered steps: a Semver bump with a reason, changelog, CI stages, deploy commands and a rollback table. It switches on when a project is ready to tag and ship. CX Codex +1 ★ 71repo stars jackin-release jackin-project jackin-release orchestrates checks, changelog formatting, and version bumps for Rust projects. Runs cargo release only after an explicit confirmation from the operator. CX Codex +1 469installs

From the same set2

More in the catalog

Project sponsors

Companies that keep this analytics open