Skip to content
Skills Library
DevOps & cloud · Automation

release

/release

Execute the grill-me-sleek release process. Use this skill when the user wants to publish a new version, create a release, bump version numbers, or says things like "release v0.2.0", "publish a new version", "cut a release", "ship it", or "prepare release". Also use when the user mentions CHANGELOG updates combined with version bumping in this project.

Licence
MIT
Last repository change
02.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
2
Deprecation

No signals detected. Repository changed on 02.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Execute the grill-me-sleek release process. Use this skill when the user wants to publish a new version, create a release, bump version numbers, or says things like "release v0.2.0", "publish a new version", "cut a release", "ship it", or "prepare release". Also use when the user mentions CHANGELOG updates combined with version bumping in this project.

Triggers from the description

release v0.2.0publish a new versioncut a releaseship itprepare release
Original author description

Execute the grill-me-sleek release process. Use this skill when the user wants to publish a new version, create a release, bump version numbers, or says things like "release v0.2.0", "publish a new version", "cut a release", "ship it", or "prepare release". Also use when the user mentions CHANGELOG updates combined with version bumping in this project.

How it works

  1. Prerequisites
  2. Steps 1–4: Preparation Phase
  3. PAUSE — User Confirmation Required
  4. Steps 5–8: Commit & Publish Phase
  5. Step 9: Post-Release Verification
Original SKILL.md headings · 198 lines, 1,159 words
SKILL.md preview
---
name: release
description: >
  Execute the grill-me-sleek release process. Use this skill when the user wants to
  publish a new version, create a release, bump version numbers, or says things like
  "release v0.2.0", "publish a new version", "cut a release", "ship it", or "prepare
  release". Also use when the user mentions CHANGELOG updates combined with version
  bumping in this project.
---

# Release Process

Safe release workflow for grill-me-sleek. Every step validates before proceeding; failures report the problem + suggestion then STOP — never auto-fix.

## Prerequisites

Verify clean tree and identify current state:

```bash
git status                         # must be clean
python3 scripts/verify_versions.py # current version, whole train (must already be consistent)
git describe --tags --abbrev=0 2>/dev/null || echo "NO_TAGS"  # last tag (may not exist yet)
```

If `NO_TAGS` — this is the first release. Use the initial commit (`git rev-list --max-parents=0 HEAD`) as the baseline for CHANGELOG generation.

## Steps 1–4: Preparation Phase

### Step 1: Quality Checks

Verify that CI is green on the latest commit. The project has multi-language CI (Rust server, TypeScript web/CLI):

```bash
# Quick local checks (if toolchains are available)
cd server && cargo fmt --check && cargo clippy -- -D warnings && cargo test && cd ..
cd cli && pnpm install --frozen-lockfile && pnpm lint && pnpm test && cd ..
cd web && pnpm install --frozen-lockfile && pnpm lint && pnpm test && cd ..
```

If any check fails → report which check failed + the specific violations, STOP.

### Step 2: Version Bump

1. Show commits since last tag (or since initial commit if no tags):
   ```bash
   git log --oneline <last_tag_or_initial>..HEAD
   ```
2. **Determine version number:**
   - If the user provided a version number → **validate it:**
     1. Semver format: `X.Y.Z` or `X.Y.Z-<prerelease>` (e.g. `0.2.0-rc.4`), X/Y/Z non-negative integers
     2. Higher than current version (no downgrades)
     3. No skipped intermediate versions (e.g. 0.1.1 → 0.3.0 skips 0.2.0 → soft warning, NOT a blocker)
     4. Tag does not already exist (`git tag -l "vX.Y.Z"` / `git tag -l "vX.Y.Z-rc.N"` must be empty)
     - Present validation results as **non-binding suggestions** — the user may override any warning.
   - If the user did NOT provide a version → recommend one based on semver principles (patch=fixes, minor=features, major=breaking), using your best judgment. **Show your reasoning** (e.g. "3 feat + 2 fix commits since v0.1.1 → recommending minor bump to 0.2.0").
3. **PAUSE — confirm version number.** Present the chosen version + reasoning/validation results and wait for explicit user confirmation. Do NOT proceed until the user gives a clear affirmative response (e.g. ok / 确认 / yes / 行 / 好的 / LGTM / 没问题 / 可以 / proceed / confirm).

   **⚠️ Anti-ambiguity rule:** You MUST NOT interpret silence, vague acknowledgments, or topic-adjacent replies as consent. Only explicit affirmative words count. When in doubt, ask.

4. Bump the **unified version train** with the confirmed version:
   1. Edit `"version"` in the root `package.json` — the anchor of the train.
   2. Propagate to the whole train (member set lives in `scripts/versionlib.py`,
      shared with the gates):
      ```bash
      python3 scripts/sync-version.py
      ```
      This rewrites `cli/`, `web/`, `e2e/` `package.json`, `server/Cargo.toml`,
      `.claude-plugin/plugin.json` + `marketplace.json`, and the `README.md` /
      `README.zh.md` badges (shields.io `-` → `--` escaping handled for you).
   3. Refresh `server/Cargo.lock` for the new Cargo version —
      `cargo clippy --locked` fails the commit otherwise:
      ```bash
      cd server && cargo update -p grilling-sleek && cd ..
      ```
5. Verify the train is consistent (the prek `version-sync` hook re-runs this at
   commit — surface failures now, not mid-ceremony):
   ```bash
   python3 scripts/verify_versions.py
   ```

### Step 3: Update CHANGELOG

1. Derive changes from `git log --oneline <last_tag_or_initial>..HEAD`
2. If `CHANGELOG.md` does not exist yet, create it with header:
   ```
   # Changelog

   ```
3. Draft entry matching this format, present to user for review, then insert at TOP (after `# Changelog` header + blank line):

   ```
   ## [X.Y.Z] - YYYY-MM-DD

   ### Added
   - ...
   ### Changed
   - ...
   ### Fixed
   - ...
   ```

   Omit empty sections. Keep `# Changelog` header + blank line at the top.

   **Writing style — user-facing, not developer-facing:**
   - Each entry is **one sentence describing what the user experiences**, not what the code does.
   - ✅ Good: "Questions load faster — no more waiting for all questions before the first one appears."
   - ❌ Bad: "Split client into non-blocking push and wait."
   - ❌ Bad: "Refactored question rendering pipeline."
   - Do NOT mention implementation details (function names, architecture, internal APIs).
   - **Completely omit** chore commits, CI changes, internal refactorings, and dependency updates unless they directly affect what users see or do.

4. Verify the entry was inserted correctly (first section after header).

### Step 4: README Consistency Check

Compare `README.md` and `README_zh.md` for conflicting or contradictory information:
- Version badges must match
- Feature descriptions must agree (content may differ in detail, but must not contradict)
- Install commands must be identical
- Platform status table must match

If inconsistencies found → report them to the user and STOP.

---

## PAUSE — User Confirmation Required

Present summary:

```
Steps 1–4 complete:
- Version: X.Y.Z across the whole train (package.json + components + Cargo.toml + plugin/marketplace + README badges; verify_versions.py green)
- CHANGELOG: updated
- READMEs: verified consistent

Ready to commit and publish? Confirm to continue.
```

Do NOT proceed until the user gives a **clear affirmative response** (e.g. ok / 确认 / yes / 行 / 好的 / LGTM / 没问题 / 可以 / proceed / confirm). If the user objects or requests changes, address them and re-present the updated summary.

**⚠️ Anti-ambiguity rule:** You MUST NOT interpret silence, vague acknowledgments, or topic-adjacent replies as consent. Only explicit affirmative words count. When in doubt, ask.

---

## Steps 5–8: Commit & Publish Phase

### Step 5: Verify Release Workflow

```bash
cat .github/workflows/release.yml
```

The workflow MUST have:
- Trigger on `v*` tags
- CHANGELOG extraction step (awk to extract version-specific notes)
- `softprops/action-gh-release` with `body_path` pointing to extracted notes

If the file is missing or incomplete → create/fix it, explain what was done, and ask user to confirm before continuing.

### Step 6: Commit

```bash
git add package.json cli/package.json web/package.json e2e/package.json \
  server/Cargo.toml server/Cargo.lock \
  .claude-plugin/plugin.json .claude-plugin/marketplace.json \
  README.md README.zh.md CHANGELOG.md .github/workflows/release.yml
git commit -m "chore: release vX.Y.Z"
```

Verify: `git log --oneline -1` shows the commit, `git status` is clean.
Hook failure → report output, STOP. Never `--no-verify`.

### Step 7: Tag

```bash
git tag -a vX.Y.Z -m "Release vX.Y.Z"
```

Verify: `git tag -l "vX.Y.Z"` returns exactly the tag. If tag already exists → report, STOP.

### Step 8: Push

Confirm with user first — **destructive, visible to others**:

```bash
git push && git push --tags
```

Then provide monitoring URL: `https://github.com/jukanntenn/grill-me-sleek/actions/workflows/release.yml`

Rejected → report error, STOP. Never force push.

---

## Step 9: Post-Release Verification

Provide user with:

1. **GitHub Release**: check body matches CHANGELOG entry
   → `https://github.com/jukanntenn/grill-me-sleek/releases/tag/vX.Y.Z`
2. **Version checklist**: `python3 scripts/verify_versions.py --expect vX.Y.Z` green — the whole train carries the release; the publish workflows' `verify` job already enforced this before any artifact went out
3. **Rollback options**:
   - Delete the tag: `git tag -d vX.Y.Z && git push origin :refs/tags/vX.Y.Z`
   - Edit the GitHub Release manually via the web UI
   - Delete and re-create the Release via the web UI
   - If commit hasn't been pushed yet, `git reset --soft HEAD~1` to undo the release commit

Versions

RepositoryScoreLicence
This page · jukanntenn/grill-me-sleek100MIT
josephfung/curia100MIT
max-sixty/worktrunk100MIT
gtapps/hermitd100MIT
gtapps/hermitd100MIT
anthony-chaudhary/fak100Apache-2.0
tractorjuice/arc-kit100MIT
drvoss/everything-copilot-cli100MIT
sma1lboy/rove100MIT

Identical content appears in 2 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 8f0e12797b11 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ship-release
    Use when the user asks to release, ship, publish, cut or tag a version of a project ("release v0.2.0", "ship a patch", "bump and publish"). Bumps every version manifest, updates CHANGELOG and README badges, commits, lands it directly or through a pull request (pre-PR check,…
  • 100pypi-release
    Release a new seckit version to PyPI from this repository. Use when the user asks to publish, release, ship or tag a new version of seckit, bump the version, or check or fix the PyPI publish workflow.
  • 100version-release
    Use when bumping version, creating a release tag, or pushing a version tag. Triggers on "version up", "release", "tag push", "bump version".
  • 100releasing
    Full release lifecycle — version bump, CHANGELOG, rich release notes, tag, publish. Use when user says "release", "tag and release", "publish version", "cut a release", "new version".
  • 100ls-release
    Cut a LlamaStash release (vX.Y.Z) end to end - promote the CHANGELOG, bump Cargo.toml and the TUI goldens, commit and push, tag, watch the publish pipeline, write the GitHub release body, verify every channel. Use when asked to release, ship, or publish a new version of llamastash.
  • 90d2r-release
    Ship a new version of a Diablo II Resurrected mod to players - bump the version, write the changelog in player wording, build and publish the release package with a single fail-fast script, verify the version is live, create release pages, and update the bug list. Use after a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.