when-releasing-software-use-github-release-management

What this skill does

# GitHub Release Management Skill

## Overview

Orchestrate end-to-end software release processes with intelligent agent coordination. This skill automates version bumping, changelog generation, release candidate testing, deployment orchestration, post-release validation, and rollback procedures for GitHub-hosted projects using comprehensive CI/CD integration.

## When to Use This Skill

Activate this skill when creating production releases with automated validation, coordinating multi-environment deployments (staging, production), generating release notes and changelogs automatically, managing semantic versioning across projects, implementing deployment strategies (rolling, blue-green, canary), handling hotfix releases and emergency patches, or establishing release automation for new projects.

Use for both small single-repository releases and complex multi-service deployments, scheduled regular releases or on-demand deployments, and establishing release governance and compliance.

## Agent Coordination Architecture

### Swarm Topology

Initialize a **hierarchical topology** with release-manager as coordinator overseeing specialized deployment, testing, and documentation agents. Hierarchical structure ensures coordinated decision-making for critical release operations.

```bash
# Initialize hierarchical swarm for release management
npx claude-flow@alpha swarm init --topology hierarchical --max-agents 8 --strategy specialized
```

### Specialized Agent Roles

**Release Manager** (`release-manager`): Top-level coordinator that oversees entire release process. Makes go/no-go decisions, coordinates deployment timing, manages rollback decisions, and ensures release quality standards. Acts as release captain.

**CI/CD Engineer** (`cicd-engineer`): Manages build pipelines, deployment automation, infrastructure provisioning, and deployment strategy execution. Handles technical deployment mechanics and environment configuration.

**Test Engineer** (`tester`): Validates release candidates through automated testing, regression testing, performance testing, and smoke testing. Verifies deployment success and monitors post-deployment health.

**Code Reviewer** (`reviewer`): Performs final code review of release branch, validates security compliance, checks for last-minute issues, and approves release artifacts.

**Documentation Writer** (`docs-writer`): Generates release notes, updates changelogs, creates deployment runbooks, and documents breaking changes. Ensures comprehensive release documentation.

## Release Management Workflows (SOP)

### Workflow 1: Standard Release (Major/Minor/Patch)

Execute full release cycle from version bump to production deployment.

**Phase 1: Pre-Release Preparation**

**Step 1.1: Initialize Release Swarm**

```bash
# Set up hierarchical release swarm
mcp__claude-flow__swarm_init topology=hierarchical maxAgents=8 strategy=specialized

# Spawn release team
mcp__claude-flow__agent_spawn type=coordinator name=release-manager
mcp__claude-flow__agent_spawn type=coder name=cicd-engineer
mcp__claude-flow__agent_spawn type=researcher name=tester
mcp__claude-flow__agent_spawn type=analyst name=reviewer
mcp__claude-flow__agent_spawn type=researcher name=docs-writer
```

**Step 1.2: Determine Release Version**

```plaintext
Task("Release Manager", "
  Determine next release version:

  1. Fetch current version from package.json / Cargo.toml / VERSION file
  2. Analyze commits since last release using git log
  3. Classify changes: breaking|features|fixes|docs
  4. Apply semantic versioning rules:
     - Breaking changes → major version bump
     - New features → minor version bump
     - Bug fixes only → patch version bump
  5. Check for forced version override in environment

  Use scripts/semver.sh for version calculation
  Store version decision in memory: release/version
  Run hooks: npx claude-flow@alpha hooks pre-task --description 'version determination'
", "release-manager")
```

```bash
# Calculate next version
NEXT_VERSION=$(bash scripts/semver.sh calculate \
  --current $(cat VERSION) \
  --commits-since-tag "v$(cat VERSION)" \
  --bump-strategy "auto")
```

**Step 1.3: Create Release Branch**

```bash
# Create release branch
git checkout -b "release/v${NEXT_VERSION}"
git push origin "release/v${NEXT_VERSION}"
```

**Step 1.4: Update Version Files**

```plaintext
Task("CI/CD Engineer", "
  Update version across project files:

  1. Update package.json version field
  2. Update Cargo.toml version (if Rust project)
  3. Update VERSION or version.txt file
  4. Update hardcoded versions in documentation
  5. Update version constants in source code
  6. Commit changes: 'chore: bump version to ${NEXT_VERSION}'

  Use scripts/version-bumper.sh for automation
  Store version update status in memory: release/version-update
", "cicd-engineer")
```

**Phase 2: Release Candidate Testing**

**Step 2.1: Build Release Candidate**

```plaintext
Task("CI/CD Engineer", "
  Build release candidate artifacts:

  1. Trigger CI build for release branch
  2. Run full test suite (unit, integration, e2e)
  3. Build production artifacts (binaries, containers, packages)
  4. Sign artifacts with release signing key
  5. Upload artifacts to staging repository
  6. Generate artifact checksums

  Use scripts/build-release.sh
  Store build artifacts in memory: release/artifacts
", "cicd-engineer")
```

**Step 2.2: Deploy to Staging Environment**

```bash
# Deploy release candidate to staging
bash scripts/deploy.sh \
  --environment "staging" \
  --version "${NEXT_VERSION}" \
  --strategy "rolling" \
  --wait-for-healthy true
```

**Step 2.3: Execute Release Validation Suite**

```plaintext
Task("Test Engineer", "
  Validate release candidate in staging:

  1. Run smoke tests against staging deployment
  2. Execute regression test suite
  3. Perform load testing with production-like traffic
  4. Validate API compatibility and contracts
  5. Check database migrations successful
  6. Test rollback procedure
  7. Verify monitoring and alerting working

  Use scripts/release-validation.sh
  Store test results in memory: release/validation
", "tester")
```

**Step 2.4: Security and Compliance Review**

```plaintext
Task("Code Reviewer", "
  Perform final security and compliance checks:

  1. Scan for known vulnerabilities (npm audit, cargo audit)
  2. Check for exposed secrets in release branch
  3. Validate license compliance
  4. Review CHANGELOG for security advisories
  5. Check compliance with organizational policies
  6. Approve or flag issues blocking release

  Use references/security-checklist.md
  Store review status in memory: release/security-review
", "reviewer")
```

**Phase 3: Release Artifact Generation**

**Step 3.1: Generate Changelog**

```plaintext
Task("Documentation Writer", "
  Generate comprehensive changelog:

  1. Fetch all commits since last release
  2. Categorize by type: breaking|features|fixes|docs|chore
  3. Extract issue references and PR numbers
  4. Format using references/changelog-template.md
  5. Highlight breaking changes prominently
  6. Include migration guide if breaking changes present

  Use scripts/changelog-generator.sh
  Store changelog in memory: release/changelog
", "docs-writer")
```

**Step 3.2: Write Release Notes**

```plaintext
Task("Documentation Writer", "
  Create user-facing release notes:

  1. Summarize major features and improvements
  2. Document breaking changes with upgrade path
  3. List bug fixes with issue references
  4. Include known issues and workarounds
  5. Add installation/upgrade instructions
  6. Acknowledge contributors

  Use references/release-notes-template.md
  Store release notes in memory: release/notes
", "docs-writer")
```

**Step 3.3: Update Documentation**

```bash
# Update version in documentation
bash scripts/docs-updater.sh \
  --version "${NEXT_VERSION}" \
  --changelog "CHANGELOG.md" \
  --docs-dir "docs/"
```

**Phase 4: Production Deployment**

**Step 4.1: Create GitHub Re