release
Release
Collaborating skills
- Changelog: skill:
changelog— classify commits, determine version bump, write CHANGELOG.md entry - Git Commit: skill:
git-commit— commit the release changes with a conventional message - Create PR: skill:
create-pr— open a release PR after updating the changelog
Overview
A release is a sequence of discrete steps. Complete each one before moving to the next, and confirm with the user before pushing anything to the remote.
Step 1: Pre-flight checks
Verify the repository is in a clean, releasable state:
# Must be on main (or the designated release branch)
git branch --show-current
# Working tree must be clean
git status
# Must be up to date with remote
git fetch origin
git log HEAD..origin/main --oneline # should be empty
# Show commits since last tag (what will be released)
git describe --tags --abbrev=0 # last tag
git log $(git describe --tags --abbrev=0)..HEAD --oneline --no-merges
Stop if:
- Not on the main branch
- Uncommitted changes exist
- Local branch is behind remote — pull first
Step 2: Determine version and update changelog
Invoke the changelog skill here. It will:
- Read commits since the last tag
- Classify them into Added / Changed / Fixed / Security / etc.
- Propose the next semver version (MAJOR / MINOR / PATCH)
- Write the new versioned section in
CHANGELOG.md
Confirm the proposed version and changelog content with the user before continuing.
Step 3: Update version in project files
After confirming the version, update the version string wherever the project declares it.
Detect which files to update:
# Common version files — check which exist
ls package.json pyproject.toml Cargo.toml mix.exs version.rb VERSION 2>/dev/null
Update the version field in whichever files are present:
# Node.js / npm
npm version <new-version> --no-git-tag-version
# Or edit manually for other ecosystems
# Python: pyproject.toml → [project] version = "x.x.x"
# Ruby gem: version.rb → VERSION = "x.x.x"
# Plain file: echo "x.x.x" > VERSION
Step 4: Commit release changes
Use the git-commit skill with a conventional release commit:
git add CHANGELOG.md package.json # (and any other version files updated)
git commit -m "chore: release vX.X.X"
Step 5: Create and push the git tag
# Annotated tag with the changelog entry as the message
git tag -a vX.X.X -m "Release vX.X.X"
# Review what will be pushed
git log --oneline -3
git tag -l "vX.X.X"
Confirm with the user before pushing.
# Push commit and tag together
git push origin main
git push origin vX.X.X
Step 6: Create GitHub release
Extract the changelog entry for this version to use as the release body:
# Show the section for this version from CHANGELOG.md
awk '/^## \[X\.X\.X\]/,/^## \[/' CHANGELOG.md | head -n -1
Create the release:
gh release create vX.X.X \
--title "vX.X.X" \
--notes "$(awk '/^## \[X\.X\.X\]/,/^## \[/' CHANGELOG.md | head -n -1)"
For a pre-release:
gh release create vX.X.X --prerelease --title "vX.X.X (pre-release)" --notes "..."
Step 7: Post-release (project-specific)
Depending on the project, additional publish steps may be needed. Check and run only what applies:
# npm package
npm publish
# Python package
uv build && uv publish
# Ruby gem
gem build *.gemspec && gem push *.gem
These are opt-in — only run if the project is a published package.
Full sequence summary
| Step | Action | Requires confirmation |
|---|---|---|
| 1 | Pre-flight checks | — |
| 2 | Changelog + version decision | Yes — confirm version |
| 3 | Update version files | — |
| 4 | Commit release changes | — |
| 5 | Tag + push | Yes — before pushing |
| 6 | GitHub release | Yes — review release notes |
| 7 | Publish (if applicable) | Yes |
Checklist
- On main branch, working tree clean, up to date with remote
- Commits since last tag reviewed
- Version confirmed (MAJOR / MINOR / PATCH)
- CHANGELOG.md updated with dated versioned section
- Version files updated (
package.json, etc.) - Release commit created:
chore: release vX.X.X - Annotated tag created:
git tag -a vX.X.X - Commit and tag pushed to remote
- GitHub release created with changelog notes
- Package published (if applicable)
More from mguinada/agent-skills
refactor
TDD-based code refactoring preserving behavior through tests. Use Red-Green-Refactor cycles to apply refactoring patterns one test-verified change at a time. **TRIGGERS**: 'clean up code', 'make code simpler', 'reduce complexity', 'refactor this', 'apply DRY', 'extract method', 'remove duplication'. **DISTINCT FROM**: Adding features (use /tdd) or fixing bugs. **PROACTIVE**: Auto-invoke when test-covered code has complexity (functions >50 lines, high cyclomatic complexity, duplication).
16ai-engineering
Build AI agents and agentic workflows. Use when designing/building/debugging agentic systems: choosing workflows vs agents, implementing prompt patterns (chaining/routing/parallelization/orchestrator-workers/evaluator-optimizer), building autonomous agents with tools, designing ACI/tool specs, or troubleshooting/optimizing implementations. **PROACTIVE ACTIVATION**: Auto-invoke when building agentic applications, designing workflows vs agents, or implementing agent patterns. **DETECTION**: Check for agent code (MCP servers, tool defs, .mcp.json configs), or user mentions of \"agent\", \"workflow\", \"agentic\", \"autonomous\". **USE CASES**: Designing agentic systems, choosing workflows vs agents, implementing prompt patterns, building agents with tools, designing ACI/tool specs, troubleshooting/optimizing agents.
13git-commit
Generate concise, descriptive git commit messages following best practices. Use when creating git commits from staged changes, crafting commit messages, or reviewing commit message quality. Use when the user says /commit or asks to create a git commit. **PROACTIVE ACTIVATION**: Auto-invoke when staged changes detected or user asks to commit/save work. **DETECTION**: Run git status - if staged changes exist, offer to commit. User says \"commit\", \"save\", \"done with feature\". **USE CASES**: Staged changes detected, work completed, user wants to save progress.
12tdd
Guide Test-Driven Development workflow (Red-Green-Refactor) for new features, bug fixes, and refactoring. Supports both Python (pytest) and Ruby (RSpec). Use when writing tests, implementing features, or following TDD methodology. **PROACTIVE ACTIVATION**: Auto-invoke when implementing features or fixing bugs in projects with test infrastructure. **DETECTION**: Check for tests/ directory, pytest.ini, pyproject.toml with pytest config, spec/ directory, .rspec file, or *_spec.rb files. **USE CASES**: Writing production code, fixing bugs, adding features, legacy code characterization.
11create-pr
Creates GitHub pull requests with properly formatted titles, a body matching the project's PR template, and appropriate type/scope labels. Automatically creates labels if they don't exist. Use when creating PRs, submitting changes for review, or when the user says /pr or asks to create a pull request. **PROACTIVE ACTIVATION**: Auto-invoke when a branch has commits ahead of main and the user signals the work is ready. **DETECTION**: Run git log origin/main..HEAD - if commits exist and user signals readiness, offer to open a PR. User says \"open a PR\", \"ready for review\", \"this is done\", \"let's merge\", \"submit this\". **USE CASES**: Feature or fix complete, user finished a series of commits and mentions review or merging.
11prompt-engineering
Creates system prompts, writes tool descriptions, and structures agent instructions for agentic systems. Use when the user asks to create, generate, or design prompts for AI agents, especially for tool-using agents, planning agents, or autonomous systems. **PROACTIVE ACTIVATION**: Auto-invoke when designing prompts for agents, tools, or agentic workflows in AI projects. **DETECTION**: Check for agent/tool-related code, prompt files, or user mentions of \"prompt\", \"agent\", \"LLM\". **USE CASES**: Designing system prompts, tool descriptions, agent instructions, prompt optimization, reducing hallucinations.
10