Skip to main content
skill CX Codex

release · shpigford — Claude Code skill: ship nurb with one command

The skill ships a complete nurb release: bumps engine and desktop versions, writes the changelog, builds signed DMGs for macOS, notarizes them, and uploads to GitHub Releases with the updater feed.

MIT 106 installs ★ 653 updated 2026-11-16

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

What release does

This skill orchestrates a full release cycle for the nurb project. It increments versions in engine/pyproject.toml, desktop/src-tauri/tauri.conf.json, and two package.json files, synchronizes workspace pins, generates the changelog with /changelog, refreshes the site hero image, and opens a PR. Once merged, it builds the desktop app for Apple silicon and Intel, signs and notarizes both DMGs, verifies the certificate chain, creates a vX.Y.Z git tag, publishes a GitHub release with both DMGs and updater archives, and uploads latest.json to desktop-latest.

Before starting, the skill runs preflight checks: gh auth, presence of desktop/.env, the updater key at ~/.tauri/nurb-desktop.key, and a codesigning certificate in the keychain. Without the updater key, installed apps cannot receive updates — the skill stops if the key is missing. The build takes around fifteen minutes. After publishing, the skill probes three endpoints: DMG redirects and the version in latest.json.

What it helps with

  • ship a release for a project with an engine and a desktop app
  • synchronize versions across pyproject.toml, tauri.conf.json, and package.json
  • sign and notarize macOS DMGs
  • publish a GitHub release with updater feed for installed apps
  • verify download availability and latest.json version

Example prompts for the agent

  • Ship version 1.2.0
  • Cut a release, pick the version yourself
  • Release it as 2.0.0-beta.1

How to install release

1Skills CLI (Vercel)

npx skills add Shpigford/nurb --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 to install release in Claude Code?

Run npx skills add Shpigford/nurb --skill release -a claude-code, the skill will be placed in ~/.claude/skills/release/SKILL.md.

What does the release skill do?

The skill ships a complete nurb release: synchronizes engine and app versions, generates the changelog, opens a PR, then after merge builds signed macOS DMGs, publishes the GitHub release with updater archives, and updates the latest.json feed.

What does release need to run?

The skill requires gh auth with write access to the repository, a desktop/.env file, the updater key at ~/.tauri/nurb-desktop.key, and a Developer ID Application certificate in the macOS keychain. Without the updater key, the skill will refuse to start.

Source text

SKILL.md · MIT
---
name: release
description: Cut a full nurb release, one version across the engine and the desktop app. Bumps every version and workspace pin and writes the changelog into one release PR, riding the current branch when work is in flight, then after the merge runs the desktop build and uploads the DMGs and the update feed to GitHub Releases. Use when the user says "release", "cut a release", "ship it as X.Y.Z", or "push a release".
---

# Releasing nurb

One release ships everything under one version: the signed DMGs, the in-app update feed, and the site changelog. The engine is not published on its own; the app bundles its wheel, so the `vX.Y.Z` GitHub release carries the DMGs and the updater archives, and the rolling `desktop-latest` prerelease carries the `latest.json` installed apps poll. This skill runs the whole ceremony. The one human act left in it is merging the bump PR, and that merge is the user approving the release.

## Step 0: Preflight

All of these must pass before touching anything. If one fails, say which and stop.

```bash
gh auth status
test -f desktop/.env
test -f ~/.tauri/nurb-desktop.key
security find-identity -v -p codesigning | grep -q "Developer ID Application"
command -v shlock
git fetch origin main --tags
```

The updater key check matters most: without `~/.tauri/nurb-desktop.key` shipped apps cannot update, and generating a fresh key would strand every existing install. If it is missing, stop and tell the user; never regenerate it. The `gh` login must be able to write to Shpigford/nurb; the script checks that before it builds.

Start from up-to-date origin/main. One PR is the release: if the current branch has work in flight, the bump and changelog ride that branch and its PR becomes the release PR. Only cut a fresh branch when the workspace is clean and the release is just collecting already-merged work.

## Step 1: Pick the version

If the user named a version, use it. Otherwise decide and propose one: read what's merged since the last tag, recommend a minor bump for new capabilities and a patch for fixes-and-polish-only, and say why in one line. The PR is the proposal; merging it is the user's yes.

```bash
gh release list --limit 5
gh pr list --state merged --base main --limit 50 --json title,mergedAt
```

Versions are PEP 440 in `engine/pyproject.toml` and SemVer everywhere else: `1.0.0a1` there is `1.0.0-alpha.1` in the app. A prerelease such as `1.0.0b1` is `1.0.0-beta.1` in the app, and its git tag keeps the PEP 440 spelling (`v1.0.0b1`).

## Step 2: The release PR

Three shipped versions and the two exact workspace pins move together; tests enforce the whole set:

```bash
cd engine && uv version X.Y.Z
```

then, using the SemVer spelling:

- `version` in `desktop/src-tauri/tauri.conf.json`
- `version` in `packages/ui/package.json`
- `@nurb/ui` in `desktop/package.json`
- `@nurb/ui` in `packages/workbench/package.json`

Run `npm install --package-lock-only` at the repository root after those edits, so `package-lock.json` records the new package version and both pins. A stale exact pin makes a clean `npm ci` look for the unpublished package on npm instead of linking the workspace.

Then write the changelog into the same PR: run /changelog for the pending version. Pre-merge there is no tag yet, so it draws from the PRs merged since the last tag plus this branch's own changes, dated today.

Refresh the site's hero in the same PR: `npm run site:hero --workspace packages/ui`. It draws the `hero` sheet in `packages/ui/gallery/sheets.tsx` from the components the app ships and writes `site/app.jpg`, so nurb.app shows the app as it is in this release. Look at `site/app.jpg` before committing it. If the part, the conversation or the numbers on that sheet no longer match what the app does, fix the sheet, not the image.

Prove the agreement before pushing: `cd engine && uv run pytest tests/test_version.py -q`, then run `npm ci --ignore-scripts` at the repository root to prove a clean workspace install. Commit the bump, lockfile, changelog and hero images together with a plain-sentence message, push, and open the PR against main with the release summary as the body (what shipped, in user-visible terms). Then stop and hand the merge to the user.

## Step 3: After the merge

Check out the merged main, then run the desktop half:

```bash
RELEASE_ROOT="${CONDUCTOR_ROOT_PATH:-$(git rev-parse --show-toplevel)}"
git -C "$RELEASE_ROOT" checkout main
git -C "$RELEASE_ROOT" pull --ff-only origin main
(cd "$RELEASE_ROOT/desktop" && scripts/release.sh)
```

In Conductor, `CONDUCTOR_ROOT_PATH` selects the repository's main checkout; do not try to check out `main` inside the workspace worktree because Git already has that branch checked out there.

A fresh worktree has no `desktop/node_modules`, and the script dies immediately with `tauri: command not found`. Run `npm ci` at the repo root first if it is missing.

It can take more than an hour, most of it waiting in Apple's notarization queue, so give a background run the longest timeout available (two hours). If it is killed anyway, rerun it in the same checkout: a build already finished for this version and commit is reused, and a DMG Apple already accepted is stapled rather than submitted again. The work: signed builds for Apple silicon and Intel, notarization, stapling, chain verification, then the `v<engine version>` git tag pushed to origin, a draft `vX.Y.Z` release with `nurb.dmg`, `nurb-intel.dmg`, both updater archives and their signatures, the release published as Latest, and `latest.json` uploaded to `desktop-latest`. The draft keeps the site's download links on the previous release until every file is up. Re-running resumes an unpublished draft; once the release is published or the version is in the feed, it refuses to upload twice, and a missing artifact under a live version is a hard stop rather than an in-place repair. A machine-local lock serializes releases on this Mac, and the feed is rechecked after the build before anything uploads. It needs this Mac; the signing cert and updater key live here by design.

## Step 4: Verify, then report

Three probes. The two downloads must return a redirect, and the feed must say X.Y.Z:

```bash
curl -sI https://github.com/Shpigford/nurb/releases/latest/download/nurb.dmg | head -1
curl -sI https://github.com/Shpigford/nurb/releases/latest/download/nurb-intel.dmg | head -1
curl -sL https://github.com/Shpigford/nurb/releases/download/desktop-latest/latest.json | python3 -c "import json,sys; print(json.load(sys.stdin)['version'])"
```

Report with the release URL and what is now true: desktop users see the one-click update at next launch, new downloads from the site carry the new version, and the site's changelog names what changed. If any probe disagrees, say which channel is not live yet instead of calling the release done.

© Shpigford · MIT · Shpigford/nurb

Similar skills

All skills for DevOps and infrastructure →

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 schpet 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. CX Codex +1 3,900installs 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 re0-release LilMGenius re0-release is a Claude Code skill that takes repository changes through the project’s release procedure and publishes a tag after approval. A person starts it when the decision to ship has been made. CX Codex +1 1,400installs release-loop alfredoperez release-loop is a command for Claude Code and Codex that moves a batch of changes through fixes, QA, and release. It prepares a report and waits for approval before publishing. CX Codex +1 ★ 110repo stars release-bump mikeyobrien release-bump walks ralph-orchestrator through a release: raise the version, build, test, tag. Meant for the moment fixes are committed and publishing is next. CX Codex +1 ★ 3,206repo stars dev:release raphaelchristi dev:release is a Claude Code skill that runs a release end to end: it builds the changelog, bumps the version, tags the commit, and publishes the package to npm. CX Codex +1 ★ 58repo stars cmux-release manaflow-ai Automates the cmux release pipeline by extracting changelog lines from pull requests, bumping versions, and running safety checks. CX Codex +1 5,000installs 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

From the same set4

Project sponsors

Companies that keep this analytics open