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
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