What does the Github Release Management AI skill do?

Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management

Why use Github Release Management on TypingMind?

Because you install it once and use it with any model. Github Release Management is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Github Release Management in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/dxkjuanjuan/ui-forge/tree/main/skills/github-release-management. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Github Release Management?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Github Release Management?

As many as you like. As long as a model supports skills, you can use Github Release Management with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Github Release Management AI skill free?

It is published on GitHub by dxkjuanjuan. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

Github Release Management by dxkjuanjuan — AI Skill for Any LLM

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

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

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

bash
# Update package.json version
npm version patch  # or minor, major

# Push version tag
git push --follow-tags

Simple Deployment

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

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

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

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

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

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

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

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

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

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

yaml
# .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

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

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

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

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

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

yaml
# .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

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

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

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

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

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

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

bash
# Comprehensive security validation
npx claude-flow github release-security \
  --scan-dependencies \
  --check-secrets \
  --audit-permissions \
  --sign-artifacts \
  --sbom-generation \
  --vulnerability-report

Compliance Validation

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

yaml
# .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@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v4
        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

yaml
# .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

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

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

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

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

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

Release Checklist

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 Team

Publisher	dxkjuanjuan
Repository	`ui-forge`
Skill name	`github-release-management`
Stars	3
Forks	0
Bundled files	Instructions only
Links	Skill source Repository Homepage

Overview

Installation

Install in TypingMind

Install in another agent

Use it in TypingMind

Works with any AI model

Skill instructions

GitHub Release Management Skill

Quick Start

Simple Release Flow

Full Automated Release

Core Capabilities

1. Release Planning & Version Management

2. Automated Testing & Validation

3. Build & Deployment Orchestration

4. Documentation & Communication

Progressive Disclosure: Level 1 - Basic Usage

Essential Release Commands

Create Release Draft

Basic Version Bump

Simple Deployment

Quick Integration Example

Progressive Disclosure: Level 2 - Swarm Coordination

AI Swarm Release Orchestration

Initialize Release Swarm

Coordinated Release Workflow

Release Agent Specializations

Changelog Agent

Version Agent

Build Agent

Test Agent

Deploy Agent

Progressive Disclosure: Level 3 - Advanced Workflows

Multi-Package Release Coordination

Monorepo Release Strategy

Progressive Deployment Strategy

Staged Rollout Configuration

Execute Staged Deployment

Multi-Repository Coordination

Coordinated Multi-Repo Release

Cross-Repo Dependency Management

Hotfix Emergency Procedures

Emergency Hotfix Workflow

Automated Hotfix Process

Progressive Disclosure: Level 4 - Enterprise Features

Release Configuration Management

Comprehensive Release Config

Advanced Testing Strategies

Comprehensive Validation Suite

Backward Compatibility Testing

Performance Regression Detection

Release Monitoring & Analytics

Real-Time Release Monitoring

Release Analytics & Insights

Automated Rollback Configuration

Security & Compliance

Security Scanning

Compliance Validation

GitHub Actions Integration

Complete Release Workflow

Hotfix Workflow

Best Practices & Patterns

Release Planning Guidelines

1. Regular Release Cadence

2. Feature Freeze Strategy

3. Version Management Rules

Automation Recommendations

1. Comprehensive CI/CD Pipeline

2. Progressive Deployment

3. Monitoring & Observability

Documentation Standards

1. Changelog Requirements

2. Release Notes Content

3. API Documentation

Troubleshooting & Common Issues

Issue: Failed Release Build

Issue: Test Failures in CI

Issue: Deployment Rollback Needed

Issue: Version Conflicts

Performance Metrics & Benchmarks