Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management
GitHub Release Management Skill
Intelligent release automation and orchestration using AI swarms for comprehensive software releases - from changelog generation to multi-platform deployment with rollback capabilities.
Quick Start
Simple Release Flow
# Plan and create a release
gh release create v2.0.0 \
--draft \
--generate-notes \
--title "Release v2.0.0"
Orchestrate with swarm
npx claude-flow github release-create
--version "2.0.0"
--build-artifacts
--deploy-targets "npm,docker,github"
### Full Automated Release
```bash
# Initialize release swarm
npx claude-flow swarm init --topology hierarchical
# Execute complete release pipeline
npx claude-flow sparc pipeline "Release v2.0.0 with full validation"
Core Capabilities
1. Release Planning & Version Management
Semantic version analysis and suggestion
Breaking change detection from commits
Release timeline generation
Multi-package version coordination
2. Automated Testing & Validation
Multi-stage test orchestration
Cross-platform compatibility testing
Performance regression detection
Security vulnerability scanning
3. Build & Deployment Orchestration
Multi-platform build coordination
Parallel artifact generation
Progressive deployment strategies
Automated rollback mechanisms
4. Documentation & Communication
Automated changelog generation
Release notes with categorization
Migration guide creation
Stakeholder notification
Progressive Disclosure: Level 1 - Basic Usage
Essential Release Commands
Create Release Draft
# Get last release tag
LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
# Generate changelog from commits
CHANGELOG=$(gh api repos/:owner/:repo$compare/${LAST_TAG}...HEAD \
--jq '.commits[].commit.message')
# Create draft release
gh release create v2.0.0 \
--draft \
--title "Release v2.0.0" \
--notes "$CHANGELOG" \
--target main
Basic Version Bump
# Update package.json version
npm version patch # or minor, major
# Push version tag
git push --follow-tags
Simple Deployment
# Build and publish npm package
npm run build
npm publish
# Create GitHub release
gh release create $(npm pkg get version) \
--generate-notes
Quick Integration Example
// Simple release preparation in Claude Code
[Single Message]:
// Update version files
Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })
// Generate changelog
Bash("gh api repos/:owner/:repo$compare$v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")
// Create release branch
Bash("git checkout -b release$v2.0.0")
Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")
// Create PR
Bash("gh pr create --title 'Release v2.0.0' --body 'Automated release preparation'")
Progressive Disclosure: Level 2 - Swarm Coordination
AI Swarm Release Orchestration
Initialize Release Swarm
// Set up coordinated release team
[Single Message - Swarm Initialization]:
mcp__claude-flow__swarm_init {
topology: "hierarchical",
maxAgents: 6,
strategy: "balanced"
}
// Spawn specialized agents
mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }
mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }
mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }
mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }
mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }
Coordinated Release Workflow
[Single Message - Full Release Coordination]:
// Create release branch
Bash("gh api repos/:owner/:repo$git$refs --method POST -f ref='refs$heads$release$v2.0.0' -f sha=$(gh api repos/:owner/:repo$git$refs$heads$main --jq '.object.sha')")
// Orchestrate release preparation
mcp__claude-flow__task_orchestrate {
task: "Prepare release v2.0.0 with comprehensive testing and validation",
strategy: "sequential",
priority: "critical",
maxAgents: 6
}
// Update all release files
Write("package.json", "[updated version]")
Write("CHANGELOG.md", "[release changelog]")
Write("RELEASE_NOTES.md", "[detailed notes]")
// Run comprehensive validation
Bash("npm install && npm test && npm run lint && npm run build")
// Create release PR
Bash(`gh pr create \
--title "Release v2.0.0: Feature Set and Improvements" \
--head "release$v2.0.0" \
--base "main" \
--body "$(cat RELEASE_NOTES.md)"`)
// Track progress
TodoWrite { todos: [
{ content: "Prepare release branch", status: "completed", priority: "critical" },
{ content: "Run validation suite", status: "completed", priority: "high" },
{ content: "Create release PR", status: "completed", priority: "high" },
{ content: "Code review approval", status: "pending", priority: "high" },
{ content: "Merge and deploy", status: "pending", priority: "critical" }
]}
// Store release state
mcp__claude-flow__memory_usage {
action: "store",
key: "release$v2.0.0$status",
value: JSON.stringify({
version: "2.0.0",
stage: "validation_complete",
timestamp: Date.now(),
ready_for_review: true
})
}
Release Agent Specializations
Changelog Agent
# Get merged PRs between versions
PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
--jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")
# Get commit history
COMMITS=$(gh api repos/:owner/:repo$compare$v1.0.0...HEAD \
--jq '.commits[].commit.message')
# Generate categorized changelog
npx claude-flow github changelog \
--prs "$PRS" \
--commits "$COMMITS" \
--from v1.0.0 \
--to HEAD \
--categorize \
--add-migration-guide
Capabilities:
Semantic commit analysis
Breaking change detection
Contributor attribution
Migration guide generation
Multi-language support
Version Agent
# Intelligent version suggestion
npx claude-flow github version-suggest \
--current v1.2.3 \
--analyze-commits \
--check-compatibility \
--suggest-pre-release
Logic:
Analyzes commit messages and PR labels
Detects breaking changes via keywords
Suggests appropriate version bump
Handles pre-release versioning
Validates version constraints
Build Agent
# Multi-platform build coordination
npx claude-flow github release-build \
--platforms "linux,macos,windows" \
--architectures "x64,arm64" \
--parallel \
--optimize-size
Features:
Cross-platform compilation
Parallel build execution
Artifact optimization and compression
Dependency bundling
Build caching and reuse
Test Agent
# Comprehensive pre-release testing
npx claude-flow github release-test \
--suites "unit,integration,e2e,performance" \
--environments "node:16,node:18,node:20" \
--fail-fast false \
--generate-report
Deploy Agent
# Multi-target deployment orchestration
npx claude-flow github release-deploy \
--targets "npm,docker,github,s3" \
--staged-rollout \
--monitor-metrics \
--auto-rollback
Progressive Disclosure: Level 3 - Advanced Workflows
Multi-Package Release Coordination
Monorepo Release Strategy
[Single Message - Multi-Package Release]:
// Initialize mesh topology for cross-package coordination
mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 8 }
// Spawn package-specific agents
Task("Package A Manager", "Coordinate claude-flow package release v1.0.72", "coder")
Task("Package B Manager", "Coordinate ruv-swarm package release v1.0.12", "coder")
Task("Integration Tester", "Validate cross-package compatibility", "tester")
Task("Version Coordinator", "Align dependencies and versions", "coordinator")
// Update all packages simultaneously
Write("packages$claude-flow$package.json", "[v1.0.72 content]")
Write("packages$ruv-swarm$package.json", "[v1.0.12 content]")
Write("CHANGELOG.md", "[consolidated changelog]")
// Run cross-package validation
Bash("cd packages$claude-flow && npm install && npm test")
Bash("cd packages$ruv-swarm && npm install && npm test")
Bash("npm run test:integration")
// Create unified release PR
Bash(`gh pr create \
--title "Release: claude-flow v1.0.72, ruv-swarm v1.0.12" \
--body "Multi-package coordinated release with cross-compatibility validation"`)
Progressive Deployment Strategy
Staged Rollout Configuration
# .github$release-deployment.yml
deployment:
strategy: progressive
stages:
- name: canary
percentage: 5
duration: 1h
metrics:
- error-rate < 0.1%
- latency-p99 < 200ms
auto-advance: true
- name: partial
percentage: 25
duration: 4h
validation: automated-tests
approval: qa-team
- name: rollout
percentage: 50
duration: 8h
monitor: true
- name: full
percentage: 100
approval: release-manager
rollback-enabled: true
Execute Staged Deployment
# Deploy with progressive rollout
npx claude-flow github release-deploy \
--version v2.0.0 \
--strategy progressive \
--config .github$release-deployment.yml \
--monitor-metrics \
--auto-rollback-on-error
Multi-Repository Coordination
Coordinated Multi-Repo Release
# Synchronize releases across repositories
npx claude-flow github multi-release \
--repos "frontend:v2.0.0,backend:v2.1.0,cli:v1.5.0" \
--ensure-compatibility \
--atomic-release \
--synchronized \
--rollback-all-on-failure
Cross-Repo Dependency Management
[Single Message - Cross-Repo Release]:
// Initialize star topology for centralized coordination
mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }
// Spawn repo-specific coordinators
Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")
Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")
Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")
Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")
// Coordinate version updates across repos
Bash("gh api repos$org$frontend$dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")
Bash("gh api repos$org$backend$dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")
Bash("gh api repos$org$cli$dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")
// Monitor all releases
mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }
Hotfix Emergency Procedures
Emergency Hotfix Workflow
# Fast-track critical bug fix
npx claude-flow github emergency-release \
--issue 789 \
--severity critical \
--target-version v1.2.4 \
--cherry-pick-commits \
--bypass-checks security-only \
--fast-track \
--notify-all
Automated Hotfix Process
[Single Message - Emergency Hotfix]:
// Create hotfix branch from last stable release
Bash("git checkout -b hotfix$v1.2.4 v1.2.3")
// Cherry-pick critical fixes
Bash("git cherry-pick abc123def")
// Fast validation
Bash("npm run test:critical && npm run build")
// Create emergency release
Bash(`gh release create v1.2.4 \
--title "HOTFIX v1.2.4: Critical Security Patch" \
--notes "Emergency release addressing CVE-2024-XXXX" \
--prerelease=false`)
// Immediate deployment
Bash("npm publish --tag hotfix")
// Notify stakeholders
Bash(`gh issue create \
--title "๐จ HOTFIX v1.2.4 Deployed" \
--body "Critical security patch deployed. Please update immediately." \
--label "critical,security,hotfix"`)
Progressive Disclosure: Level 4 - Enterprise Features
Release Configuration Management
Comprehensive Release Config
# .github$release-swarm.yml
version: 2.0.0
release:
versioning:
strategy: semantic
breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]
feature-keywords: ["feat", "feature"]
fix-keywords: ["fix", "bugfix"]
changelog:
sections:
- title: "๐ Features"
labels: ["feature", "enhancement"]
emoji: true
- title: "๐ Bug Fixes"
labels: ["bug", "fix"]
- title: "๐ฅ Breaking Changes"
labels: ["breaking"]
highlight: true
- title: "๐ Documentation"
labels: ["docs", "documentation"]
- title: "โก Performance"
labels: ["performance", "optimization"]
- title: "๐ Security"
labels: ["security"]
priority: critical
artifacts:
- name: npm-package
build: npm run build
test: npm run test:all
publish: npm publish
registry: https:/$registry.npmjs.org
- name: docker-image
build: docker build -t app:$VERSION .
test: docker run app:$VERSION npm test
publish: docker push app:$VERSION
platforms: [linux$amd64, linux$arm64]
- name: binaries
build: .$scripts$build-binaries.sh
platforms: [linux, macos, windows]
architectures: [x64, arm64]
upload: github-release
sign: true
validation:
pre-release:
- lint: npm run lint
- typecheck: npm run typecheck
- unit-tests: npm run test:unit
- integration-tests: npm run test:integration
- security-scan: npm audit
- license-check: npm run license-check
post-release:
- smoke-tests: npm run test:smoke
- deployment-validation: .$scripts$validate-deployment.sh
- performance-baseline: npm run benchmark
deployment:
environments:
- name: staging
auto-deploy: true
validation: npm run test:e2e
approval: false
- name: production
auto-deploy: false
approval-required: true
approvers: ["release-manager", "tech-lead"]
rollback-enabled: true
health-checks:
- endpoint: $health
expected: 200
timeout: 30s
monitoring:
metrics:
- error-rate: <1%
- latency-p95: <500ms
- availability: >99.9%
- memory-usage: <80%
alerts:
- type: slack
channel: releases
on: [deploy, rollback, error]
- type: email
recipients: ["team@company.com"]
on: [critical-error, rollback]
- type: pagerduty
service: production-releases
on: [critical-error]
rollback:
auto-rollback:
triggers:
- error-rate > 5%
- latency-p99 > 2000ms
- availability < 99%
grace-period: 5m
manual-rollback:
preserve-data: true
notify-users: true
create-incident: true
Advanced Testing Strategies
Comprehensive Validation Suite
# Pre-release validation with all checks
npx claude-flow github release-validate \
--checks "
version-conflicts,
dependency-compatibility,
api-breaking-changes,
security-vulnerabilities,
performance-regression,
documentation-completeness,
license-compliance,
backwards-compatibility
" \
--block-on-failure \
--generate-report \
--upload-results
Backward Compatibility Testing
# Test against previous versions
npx claude-flow github compat-test \
--previous-versions "v1.0,v1.1,v1.2" \
--api-contracts \
--data-migrations \
--integration-tests \
--generate-report
Performance Regression Detection
# Benchmark against baseline
npx claude-flow github performance-test \
--baseline v1.9.0 \
--candidate v2.0.0 \
--metrics "throughput,latency,memory,cpu" \
--threshold 5% \
--fail-on-regression
Release Monitoring & Analytics
Real-Time Release Monitoring
# Monitor release health post-deployment
npx claude-flow github release-monitor \
--version v2.0.0 \
--metrics "error-rate,latency,throughput,adoption" \
--alert-thresholds \
--duration 24h \
--export-dashboard
Release Analytics & Insights
# Analyze release performance and adoption
npx claude-flow github release-analytics \
--version v2.0.0 \
--compare-with v1.9.0 \
--metrics "adoption,performance,stability,feedback" \
--generate-insights \
--export-report
Automated Rollback Configuration
# Configure intelligent auto-rollback
npx claude-flow github rollback-config \
--triggers '{
"error-rate": ">5%",
"latency-p99": ">1000ms",
"availability": "<99.9%",
"failed-health-checks": ">3"
}' \
--grace-period 5m \
--notify-on-rollback \
--preserve-metrics
Security & Compliance
Security Scanning
# Comprehensive security validation
npx claude-flow github release-security \
--scan-dependencies \
--check-secrets \
--audit-permissions \
--sign-artifacts \
--sbom-generation \
--vulnerability-report
Compliance Validation
# Ensure regulatory compliance
npx claude-flow github release-compliance \
--standards "SOC2,GDPR,HIPAA" \
--license-audit \
--data-governance \
--audit-trail \
--generate-attestation
GitHub Actions Integration
Complete Release Workflow
# .github$workflows$release.yml
name: Intelligent Release Workflow
on:
push:
tags: ['v*']
jobs:
release-orchestration:
runs-on: ubuntu-latest
permissions:
contents: write
packages: write
issues: write
steps:
- name: Checkout Repository
uses: actions$checkout@v3
with:
fetch-depth: 0
- name: Setup Node.js
uses: actions$setup-node@v3
with:
node-version: '20'
cache: 'npm'
- name: Authenticate GitHub CLI
run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
- name: Initialize Release Swarm
run: |
# Extract version from tag
RELEASE_TAG=${{ github.ref_name }}
PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')
# Get merged PRs for changelog
PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
--jq ".[] | select(.mergedAt > \"$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)\")")
# Get commit history
COMMITS=$(gh api repos/${{ github.repository }}$compare/${PREV_TAG}...HEAD \
--jq '.commits[].commit.message')
# Initialize swarm coordination
npx claude-flow@alpha swarm init --topology hierarchical
# Store release context
echo "$PRS" > $tmp$release-prs.json
echo "$COMMITS" > $tmp$release-commits.txt
- name: Generate Release Changelog
run: |
# Generate intelligent changelog
CHANGELOG=$(npx claude-flow@alpha github changelog \
--prs "$(cat $tmp$release-prs.json)" \
--commits "$(cat $tmp$release-commits.txt)" \
--from $PREV_TAG \
--to $RELEASE_TAG \
--categorize \
--add-migration-guide \
--format markdown)
echo "$CHANGELOG" > RELEASE_CHANGELOG.md
- name: Build Release Artifacts
run: |
# Install dependencies
npm ci
# Run comprehensive validation
npm run lint
npm run typecheck
npm run test:all
npm run build
# Build platform-specific binaries
npx claude-flow@alpha github release-build \
--platforms "linux,macos,windows" \
--architectures "x64,arm64" \
--parallel
- name: Security Scan
run: |
# Run security validation
npm audit --audit-level=moderate
npx claude-flow@alpha github release-security \
--scan-dependencies \
--check-secrets \
--sign-artifacts
- name: Create GitHub Release
run: |
# Update release with generated changelog
gh release edit ${{ github.ref_name }} \
--notes "$(cat RELEASE_CHANGELOG.md)" \
--draft=false
# Upload all artifacts
for file in dist/*; do
gh release upload ${{ github.ref_name }} "$file"
done
- name: Deploy to Package Registries
run: |
# Publish to npm
echo "/$registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
npm publish
# Build and push Docker images
docker build -t ${{ github.repository }}:${{ github.ref_name }} .
docker push ${{ github.repository }}:${{ github.ref_name }}
- name: Post-Release Validation
run: |
# Run smoke tests
npm run test:smoke
# Validate deployment
npx claude-flow@alpha github release-validate \
--version ${{ github.ref_name }} \
--smoke-tests \
--health-checks
- name: Create Release Announcement
run: |
# Create announcement issue
gh issue create \
--title "๐ Released ${{ github.ref_name }}" \
--body "$(cat RELEASE_CHANGELOG.md)" \
--label "announcement,release"
# Notify via discussion
gh api repos/${{ github.repository }}$discussions \
--method POST \
-f title="Release ${{ github.ref_name }} Now Available" \
-f body="$(cat RELEASE_CHANGELOG.md)" \
-f category_id="$(gh api repos/${{ github.repository }}$discussions$categories --jq '.[] | select(.slug=="announcements") | .id')"
- name: Monitor Release
run: |
# Start release monitoring
npx claude-flow@alpha github release-monitor \
--version ${{ github.ref_name }} \
--duration 1h \
--alert-on-errors &
Hotfix Workflow
# .github$workflows$hotfix.yml
name: Emergency Hotfix Workflow
on:
issues:
types: [labeled]
jobs:
emergency-hotfix:
if: contains(github.event.issue.labels.*.name, 'critical-hotfix')
runs-on: ubuntu-latest
steps:
- name: Create Hotfix Branch
run: |
LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')
git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE
- name: Fast-Track Testing
run: |
npm ci
npm run test:critical
npm run build
- name: Emergency Release
run: |
npx claude-flow@alpha github emergency-release \
--issue ${{ github.event.issue.number }} \
--severity critical \
--fast-track \
--notify-all
Best Practices & Patterns
Release Planning Guidelines
1. Regular Release Cadence
Weekly: Patch releases with bug fixes
Bi-weekly: Minor releases with features
Quarterly: Major releases with breaking changes
On-demand: Hotfixes for critical issues
2. Feature Freeze Strategy
Code freeze 3 days before release
Only critical bug fixes allowed
Beta testing period for major releases
Stakeholder communication plan
3. Version Management Rules
Strict semantic versioning compliance
Breaking changes only in major versions
Deprecation warnings one minor version ahead
Cross-package version synchronization
Automation Recommendations
1. Comprehensive CI/CD Pipeline
Automated testing at every stage
Security scanning before release
Performance benchmarking
Documentation generation
2. Progressive Deployment
Canary releases for early detection
Staged rollouts with monitoring
Automated health checks
Quick rollback mechanisms
3. Monitoring & Observability
Real-time error tracking
Performance metrics collection
User adoption analytics
Feedback collection automation
Documentation Standards
1. Changelog Requirements
Categorized changes by type
Breaking changes highlighted
Migration guides for major versions
Contributor attribution
2. Release Notes Content
High-level feature summaries
Detailed technical changes
Upgrade instructions
Known issues and limitations
3. API Documentation
Automated API doc generation
Example code updates
Deprecation notices
Version compatibility matrix
Troubleshooting & Common Issues
Issue: Failed Release Build
# Debug build failures
npx claude-flow@alpha diagnostic-run \
--component build \
--verbose
# Retry with isolated environment
docker run --rm -v $(pwd):$app node:20 \
bash -c "cd $app && npm ci && npm run build"
Issue: Test Failures in CI
# Run tests with detailed output
npm run test -- --verbose --coverage
# Check for environment-specific issues
npm run test:ci
# Compare local vs CI environment
npx claude-flow@alpha github compat-test \
--environments "local,ci" \
--compare
Issue: Deployment Rollback Needed
# Immediate rollback to previous version
npx claude-flow@alpha github rollback \
--to-version v1.9.9 \
--reason "Critical bug in v2.0.0" \
--preserve-data \
--notify-users
# Investigate rollback cause
npx claude-flow@alpha github release-analytics \
--version v2.0.0 \
--identify-issues
Issue: Version Conflicts
# Check and resolve version conflicts
npx claude-flow@alpha github release-validate \
--checks version-conflicts \
--auto-resolve
# Align multi-package versions
npx claude-flow@alpha github version-sync \
--packages "package-a,package-b" \
--strategy semantic
Performance Metrics & Benchmarks
Expected Performance
Release Planning: < 2 minutes
Build Process: 3-8 minutes (varies by project)
Test Execution: 5-15 minutes
Deployment: 2-5 minutes per target
Complete Pipeline: 15-30 minutes
Optimization Tips
Parallel Execution: Use swarm coordination for concurrent tasks
Caching: Enable build and dependency caching
Incremental Builds: Only rebuild changed components
Test Optimization: Run critical tests first, full suite in parallel
Success Metrics
Release Frequency: Target weekly minor releases
Lead Time: < 2 hours from commit to production
Failure Rate: < 2% of releases require rollback
MTTR: < 30 minutes for critical hotfixes
Related Resources
Documentation
GitHub CLI Documentation
Semantic Versioning Spec
Claude Flow SPARC Guide
Swarm Coordination Patterns
Related Skills
github-pr-management: PR review and merge automation
github-workflow-automation: CI/CD workflow orchestration
multi-repo-coordination: Cross-repository synchronization
deployment-orchestration: Advanced deployment strategies
Support & Community
Issues: https:/$github.com$ruvnet$claude-flow$issues
Discussions: https:/$github.com$ruvnet$claude-flow$discussions
Documentation: https:/$claude-flow.dev$docs
Appendix: Release Checklist Template
Pre-Release Checklist
Version numbers updated across all packages
Changelog generated and reviewed
Breaking changes documented with migration guide
All tests passing (unit, integration, e2e)
Security scan completed with no critical issues
Performance benchmarks within acceptable range
Documentation updated (API docs, README, examples)
Release notes drafted and reviewed
Stakeholders notified of upcoming release
Deployment plan reviewed and approved
Release Checklist
Release branch created and validated
CI/CD pipeline completed successfully
Artifacts built and verified
GitHub release created with proper notes
Packages published to registries
Docker images pushed to container registry
Deployment to staging successful
Smoke tests passing in staging
Production deployment completed
Health checks passing
Post-Release Checklist
Release announcement published
Monitoring dashboards reviewed
Error rates within normal range
Performance metrics stable
User feedback collected
Documentation links verified
Release retrospective scheduled
Next release planning initiated
Version: 2.0.0
Last Updated: 2025-10-19
Maintained By: Claude Flow Teamdon't have the plugin yet? install it then click "run inline in claude" again.