GitHub Project Management

by ruvnet6051f6702b61No license74K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated today

Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning

Instructions onlyProductivity & Workflow
AI-generated overview

Manages GitHub issues, project boards and sprints using GitHub CLI and swarm-coordinated automation commands.

What it does
This skill provides instructions and command examples for managing GitHub projects: creating and triaging issues, decomposing them into subtasks, tracking progress, and closing stale issues. It also covers project board setup, card synchronization, custom views and dashboards, sprint and release planning, and cross-board or cross-repository coordination. The deliverable is a set of documented workflows and commands rather than a script.
When to use it
Use it when you need to organize GitHub issue tracking, automate project board updates, or plan and track sprints and releases. It suits teams coordinating work across issues, boards and repositories with agent-assisted automation.
Requirements
Requires the GitHub CLI (gh) installed and authenticated, repository access permissions, and a configured ruv-swarm or claude-flow MCP server. It references MCP tools, Bash, Read, Write and TodoWrite, and uses npx commands; it ships no scripts of its own.

GitHub Project Management

Overview

A comprehensive skill for managing GitHub projects using AI swarm coordination. This skill combines intelligent issue management, automated project board synchronization, and swarm-based coordination for efficient project delivery.

Quick Start

Basic Issue Creation with Swarm Coordination

bash
# Create a coordinated issuegh issue create \  --title "Feature: Advanced Authentication" \  --body "Implement OAuth2 with social login..." \  --label "enhancement,swarm-ready"
# Initialize swarm for issuenpx claude-flow@alpha hooks pre-task --description "Feature implementation"

Project Board Quick Setup

bash
# Get project IDPROJECT_ID=$(gh project list --owner @me --format json | \  jq -r '.projects[0].id')
# Initialize board syncnpx ruv-swarm github board-init \  --project-id "$PROJECT_ID" \  --sync-mode "bidirectional"

Core Capabilities

1. Issue Management & Triage

<details> <summary><strong>Automated Issue Creation<$strong><$summary>
Single Issue with Swarm Coordination
javascript
// Initialize issue management swarmmcp__claude-flow__swarm_init { topology: "star", maxAgents: 3 }mcp__claude-flow__agent_spawn { type: "coordinator", name: "Issue Coordinator" }mcp__claude-flow__agent_spawn { type: "researcher", name: "Requirements Analyst" }mcp__claude-flow__agent_spawn { type: "coder", name: "Implementation Planner" }
// Create comprehensive issuemcp__github__create_issue {  owner: "org",  repo: "repository",  title: "Integration Review: Complete system integration",  body: `## 🔄 Integration Review
  ### Overview  Comprehensive review and integration between components.
  ### Objectives  - [ ] Verify dependencies and imports  - [ ] Ensure API integration  - [ ] Check hook system integration  - [ ] Validate data systems alignment
  ### Swarm Coordination  This issue will be managed by coordinated swarm agents for optimal progress tracking.`,  labels: ["integration", "review", "enhancement"],  assignees: ["username"]}
// Set up automated trackingmcp__claude-flow__task_orchestrate {  task: "Monitor and coordinate issue progress with automated updates",  strategy: "adaptive",  priority: "medium"}
Batch Issue Creation
bash
# Create multiple related issues using gh CLIgh issue create \  --title "Feature: Advanced GitHub Integration" \  --body "Implement comprehensive GitHub workflow automation..." \  --label "feature,github,high-priority"
gh issue create \  --title "Bug: Merge conflicts in integration branch" \  --body "Resolve merge conflicts..." \  --label "bug,integration,urgent"
gh issue create \  --title "Documentation: Update integration guides" \  --body "Update all documentation..." \  --label "documentation,integration"

<$details>

<details> <summary><strong>Issue-to-Swarm Conversion<$strong><$summary>
Transform Issues into Swarm Tasks
bash
# Get issue detailsISSUE_DATA=$(gh issue view 456 --json title,body,labels,assignees,comments)
# Create swarm from issuenpx ruv-swarm github issue-to-swarm 456 \  --issue-data "$ISSUE_DATA" \  --auto-decompose \  --assign-agents
# Batch process multiple issuesISSUES=$(gh issue list --label "swarm-ready" --json number,title,body,labels)npx ruv-swarm github issues-batch \  --issues "$ISSUES" \  --parallel
# Update issues with swarm statusecho "$ISSUES" | jq -r '.[].number' | while read -r num; do  gh issue edit $num --add-label "swarm-processing"done
Issue Comment Commands

Execute swarm operations via issue comments:

markdown
<!-- In issue comment -->$swarm analyze$swarm decompose 5$swarm assign @agent-coder$swarm estimate$swarm start

<$details>

<details> <summary><strong>Automated Issue Triage<$strong><$summary>
Auto-Label Based on Content
javascript
// .github$swarm-labels.json{  "rules": [    {      "keywords": ["bug", "error", "broken"],      "labels": ["bug", "swarm-debugger"],      "agents": ["debugger", "tester"]    },    {      "keywords": ["feature", "implement", "add"],      "labels": ["enhancement", "swarm-feature"],      "agents": ["architect", "coder", "tester"]    },    {      "keywords": ["slow", "performance", "optimize"],      "labels": ["performance", "swarm-optimizer"],      "agents": ["analyst", "optimizer"]    }  ]}
Automated Triage System
bash
# Analyze and triage unlabeled issuesnpx ruv-swarm github triage \  --unlabeled \  --analyze-content \  --suggest-labels \  --assign-priority
# Find and link duplicate issuesnpx ruv-swarm github find-duplicates \  --threshold 0.8 \  --link-related \  --close-duplicates

<$details>

<details> <summary><strong>Task Decomposition & Progress Tracking<$strong><$summary>
Break Down Issues into Subtasks
bash
# Get issue bodyISSUE_BODY=$(gh issue view 456 --json body --jq '.body')
# Decompose into subtasksSUBTASKS=$(npx ruv-swarm github issue-decompose 456 \  --body "$ISSUE_BODY" \  --max-subtasks 10 \  --assign-priorities)
# Update issue with checklistCHECKLIST=$(echo "$SUBTASKS" | jq -r '.tasks[] | "- [ ] " + .description')UPDATED_BODY="$ISSUE_BODY
## Subtasks$CHECKLIST"
gh issue edit 456 --body "$UPDATED_BODY"
# Create linked issues for major subtasksecho "$SUBTASKS" | jq -r '.tasks[] | select(.priority == "high")' | while read -r task; do  TITLE=$(echo "$task" | jq -r '.title')  BODY=$(echo "$task" | jq -r '.description')
  gh issue create \    --title "$TITLE" \    --body "$BODY
Parent issue: #456" \    --label "subtask"done
Automated Progress Updates
bash
# Get current issue stateCURRENT=$(gh issue view 456 --json body,labels)
# Get swarm progressPROGRESS=$(npx ruv-swarm github issue-progress 456)
# Update checklist in issue bodyUPDATED_BODY=$(echo "$CURRENT" | jq -r '.body' | \  npx ruv-swarm github update-checklist --progress "$PROGRESS")
# Edit issue with updated bodygh issue edit 456 --body "$UPDATED_BODY"
# Post progress summary as commentSUMMARY=$(echo "$PROGRESS" | jq -r '"## 📊 Progress Update
**Completion**: \(.completion)%**ETA**: \(.eta)
### Completed Tasks\(.completed | map("- ✅ " + .) | join("\n"))
### In Progress\(.in_progress | map("- 🔄 " + .) | join("\n"))
### Remaining\(.remaining | map("- ⏳ " + .) | join("\n"))
---🤖 Automated update by swarm agent"')
gh issue comment 456 --body "$SUMMARY"
# Update labels based on progressif [[ $(echo "$PROGRESS" | jq -r '.completion') -eq 100 ]]; then  gh issue edit 456 --add-label "ready-for-review" --remove-label "in-progress"fi

<$details>

<details> <summary><strong>Stale Issue Management<$strong><$summary>
Auto-Close Stale Issues with Swarm Analysis
bash
# Find stale issuesSTALE_DATE=$(date -d '30 days ago' --iso-8601)STALE_ISSUES=$(gh issue list --state open --json number,title,updatedAt,labels \  --jq ".[] | select(.updatedAt < \"$STALE_DATE\")")
# Analyze each stale issueecho "$STALE_ISSUES" | jq -r '.number' | while read -r num; do  # Get full issue context  ISSUE=$(gh issue view $num --json title,body,comments,labels)
  # Analyze with swarm  ACTION=$(npx ruv-swarm github analyze-stale \    --issue "$ISSUE" \    --suggest-action)
  case "$ACTION" in    "close")      gh issue comment $num --body "This issue has been inactive for 30 days and will be closed in 7 days if there's no further activity."      gh issue edit $num --add-label "stale"      ;;    "keep")      gh issue edit $num --remove-label "stale" 2>$dev$null || true      ;;    "needs-info")      gh issue comment $num --body "This issue needs more information. Please provide additional context or it may be closed as stale."      gh issue edit $num --add-label "needs-info"      ;;  esacdone
# Close issues that have been stale for 37+ daysgh issue list --label stale --state open --json number,updatedAt \  --jq ".[] | select(.updatedAt < \"$(date -d '37 days ago' --iso-8601)\") | .number" | \  while read -r num; do    gh issue close $num --comment "Closing due to inactivity. Feel free to reopen if this is still relevant."  done

<$details>

2. Project Board Automation

<details> <summary><strong>Board Initialization & Configuration<$strong><$summary>
Connect Swarm to GitHub Project
bash
# Get project detailsPROJECT_ID=$(gh project list --owner @me --format json | \  jq -r '.projects[] | select(.title == "Development Board") | .id')
# Initialize swarm with projectnpx ruv-swarm github board-init \  --project-id "$PROJECT_ID" \  --sync-mode "bidirectional" \  --create-views "swarm-status,agent-workload,priority"
# Create project fields for swarm trackinggh project field-create $PROJECT_ID --owner @me \  --name "Swarm Status" \  --data-type "SINGLE_SELECT" \  --single-select-options "pending,in_progress,completed"
Board Mapping Configuration
yaml
# .github$board-sync.ymlversion: 1project:  name: "AI Development Board"  number: 1
mapping:  # Map swarm task status to board columns  status:    pending: "Backlog"    assigned: "Ready"    in_progress: "In Progress"    review: "Review"    completed: "Done"    blocked: "Blocked"
  # Map agent types to labels  agents:    coder: "🔧 Development"    tester: "🧪 Testing"    analyst: "📊 Analysis"    designer: "🎨 Design"    architect: "🏗️ Architecture"
  # Map priority to project fields  priority:    critical: "🔴 Critical"    high: "🟡 High"    medium: "🟢 Medium"    low: "⚪ Low"
  # Custom fields  fields:    - name: "Agent Count"      type: number      source: task.agents.length    - name: "Complexity"      type: select      source: task.complexity    - name: "ETA"      type: date      source: task.estimatedCompletion

<$details>

<details> <summary><strong>Task Synchronization<$strong><$summary>
Real-time Board Sync
bash
# Sync swarm tasks with project cardsnpx ruv-swarm github board-sync \  --map-status '{    "todo": "To Do",    "in_progress": "In Progress",    "review": "Review",    "done": "Done"  }' \  --auto-move-cards \  --update-metadata
# Enable real-time board updatesnpx ruv-swarm github board-realtime \  --webhook-endpoint "https:/$api.example.com$github-sync" \  --update-frequency "immediate" \  --batch-updates false
Convert Issues to Project Cards
bash
# List issues with labelISSUES=$(gh issue list --label "enhancement" --json number,title,body)
# Add issues to projectecho "$ISSUES" | jq -r '.[].number' | while read -r issue; do  gh project item-add $PROJECT_ID --owner @me --url "https:/$github.com/$GITHUB_REPOSITORY$issues/$issue"done
# Process with swarmnpx ruv-swarm github board-import-issues \  --issues "$ISSUES" \  --add-to-column "Backlog" \  --parse-checklist \  --assign-agents

<$details>

<details> <summary><strong>Smart Card Management<$strong><$summary>
Auto-Assignment
bash
# Automatically assign cards to agentsnpx ruv-swarm github board-auto-assign \  --strategy "load-balanced" \  --consider "expertise,workload,availability" \  --update-cards
Intelligent Card State Transitions
bash
# Smart card movement based on rulesnpx ruv-swarm github board-smart-move \  --rules '{    "auto-progress": "when:all-subtasks-done",    "auto-review": "when:tests-pass",    "auto-done": "when:pr-merged"  }'
Bulk Operations
bash
# Bulk card operationsnpx ruv-swarm github board-bulk \  --filter "status:blocked" \  --action "add-label:needs-attention" \  --notify-assignees

<$details>

<details> <summary><strong>Custom Views & Dashboards<$strong><$summary>
View Configuration
javascript
// Custom board views{  "views": [    {      "name": "Swarm Overview",      "type": "board",      "groupBy": "status",      "filters": ["is:open"],      "sort": "priority:desc"    },    {      "name": "Agent Workload",      "type": "table",      "groupBy": "assignedAgent",      "columns": ["title", "status", "priority", "eta"],      "sort": "eta:asc"    },    {      "name": "Sprint Progress",      "type": "roadmap",      "dateField": "eta",      "groupBy": "milestone"    }  ]}
Dashboard Configuration
javascript
// Dashboard with performance widgets{  "dashboard": {    "widgets": [      {        "type": "chart",        "title": "Task Completion Rate",        "data": "completed-per-day",        "visualization": "line"      },      {        "type": "gauge",        "title": "Sprint Progress",        "data": "sprint-completion",        "target": 100      },      {        "type": "heatmap",        "title": "Agent Activity",        "data": "agent-tasks-per-day"      }    ]  }}

<$details>

3. Sprint Planning & Tracking

<details> <summary><strong>Sprint Management<$strong><$summary>
Initialize Sprint with Swarm Coordination
bash
# Manage sprints with swarmsnpx ruv-swarm github sprint-manage \  --sprint "Sprint 23" \  --auto-populate \  --capacity-planning \  --track-velocity
# Track milestone progressnpx ruv-swarm github milestone-track \  --milestone "v2.0 Release" \  --update-board \  --show-dependencies \  --predict-completion
Agile Development Board Setup
bash
# Setup agile boardnpx ruv-swarm github agile-board \  --methodology "scrum" \  --sprint-length "2w" \  --ceremonies "planning,review,retro" \  --metrics "velocity,burndown"
Kanban Flow Board Setup
bash
# Setup kanban boardnpx ruv-swarm github kanban-board \  --wip-limits '{    "In Progress": 5,    "Review": 3  }' \  --cycle-time-tracking \  --continuous-flow

<$details>

<details> <summary><strong>Progress Tracking & Analytics<$strong><$summary>
Board Analytics
bash
# Fetch project dataPROJECT_DATA=$(gh project item-list $PROJECT_ID --owner @me --format json)
# Get issue metricsISSUE_METRICS=$(echo "$PROJECT_DATA" | jq -r '.items[] | select(.content.type == "Issue")' | \  while read -r item; do    ISSUE_NUM=$(echo "$item" | jq -r '.content.number')    gh issue view $ISSUE_NUM --json createdAt,closedAt,labels,assignees  done)
# Generate analytics with swarmnpx ruv-swarm github board-analytics \  --project-data "$PROJECT_DATA" \  --issue-metrics "$ISSUE_METRICS" \  --metrics "throughput,cycle-time,wip" \  --group-by "agent,priority,type" \  --time-range "30d" \  --export "dashboard"
Performance Reports
bash
# Track and visualize progressnpx ruv-swarm github board-progress \  --show "burndown,velocity,cycle-time" \  --time-period "sprint" \  --export-metrics
# Generate reportsnpx ruv-swarm github board-report \  --type "sprint-summary" \  --format "markdown" \  --include "velocity,burndown,blockers" \  --distribute "slack,email"
KPI Tracking
bash
# Track board performancenpx ruv-swarm github board-kpis \  --metrics '[    "average-cycle-time",    "throughput-per-sprint",    "blocked-time-percentage",    "first-time-pass-rate"  ]' \  --dashboard-url
# Track team performancenpx ruv-swarm github team-metrics \  --board "Development" \  --per-member \  --include "velocity,quality,collaboration" \  --anonymous-option

<$details>

<details> <summary><strong>Release Planning<$strong><$summary>
Release Coordination
bash
# Plan releases using board datanpx ruv-swarm github release-plan-board \  --analyze-velocity \  --estimate-completion \  --identify-risks \  --optimize-scope

<$details>

4. Advanced Coordination

<details> <summary><strong>Multi-Board Synchronization<$strong><$summary>
Cross-Board Sync
bash
# Sync across multiple boardsnpx ruv-swarm github multi-board-sync \  --boards "Development,QA,Release" \  --sync-rules '{    "Development->QA": "when:ready-for-test",    "QA->Release": "when:tests-pass"  }'
# Cross-organization syncnpx ruv-swarm github cross-org-sync \  --source "org1/Project-A" \  --target "org2/Project-B" \  --field-mapping "custom" \  --conflict-resolution "source-wins"

<$details>

<details> <summary><strong>Issue Dependencies & Epic Management<$strong><$summary>
Dependency Resolution
bash
# Handle issue dependenciesnpx ruv-swarm github issue-deps 456 \  --resolve-order \  --parallel-safe \  --update-blocking
Epic Coordination
bash
# Coordinate epic-level swarmsnpx ruv-swarm github epic-swarm \  --epic 123 \  --child-issues "456,457,458" \  --orchestrate

<$details>

<details> <summary><strong>Cross-Repository Coordination<$strong><$summary>
Multi-Repo Issue Management
bash
# Handle issues across repositoriesnpx ruv-swarm github cross-repo \  --issue "org$repo#456" \  --related "org$other-repo#123" \  --coordinate

<$details>

<details> <summary><strong>Team Collaboration<$strong><$summary>
Work Distribution
bash
# Distribute work among teamnpx ruv-swarm github board-distribute \  --strategy "skills-based" \  --balance-workload \  --respect-preferences \  --notify-assignments
Standup Automation
bash
# Generate standup reportsnpx ruv-swarm github standup-report \  --team "frontend" \  --include "yesterday,today,blockers" \  --format "slack" \  --schedule "daily-9am"
Review Coordination
bash
# Coordinate reviews via boardnpx ruv-swarm github review-coordinate \  --board "Code Review" \  --assign-reviewers \  --track-feedback \  --ensure-coverage

<$details>

Issue Templates

Integration Issue Template

markdown
## 🔄 Integration Task
### Overview[Brief description of integration requirements]
### Objectives- [ ] Component A integration- [ ] Component B validation- [ ] Testing and verification- [ ] Documentation updates
### Integration Areas#### Dependencies- [ ] Package.json updates- [ ] Version compatibility- [ ] Import statements
#### Functionality- [ ] Core feature integration- [ ] API compatibility- [ ] Performance validation
#### Testing- [ ] Unit tests- [ ] Integration tests- [ ] End-to-end validation
### Swarm Coordination- **Coordinator**: Overall progress tracking- **Analyst**: Technical validation- **Tester**: Quality assurance- **Documenter**: Documentation updates
### Progress TrackingUpdates will be posted automatically by swarm agents during implementation.
---🤖 Generated with Claude Code

Bug Report Template

markdown
## 🐛 Bug Report
### Problem Description[Clear description of the issue]
### Expected Behavior[What should happen]
### Actual Behavior[What actually happens]
### Reproduction Steps1. [Step 1]2. [Step 2]3. [Step 3]
### Environment- Package: [package name and version]- Node.js: [version]- OS: [operating system]
### Investigation Plan- [ ] Root cause analysis- [ ] Fix implementation- [ ] Testing and validation- [ ] Regression testing
### Swarm Assignment- **Debugger**: Issue investigation- **Coder**: Fix implementation- **Tester**: Validation and testing
---🤖 Generated with Claude Code

Feature Request Template

markdown
## ✨ Feature Request
### Feature Description[Clear description of the proposed feature]
### Use Cases1. [Use case 1]2. [Use case 2]3. [Use case 3]
### Acceptance Criteria- [ ] Criterion 1- [ ] Criterion 2- [ ] Criterion 3
### Implementation Approach#### Design- [ ] Architecture design- [ ] API design- [ ] UI/UX mockups
#### Development- [ ] Core implementation- [ ] Integration with existing features- [ ] Performance optimization
#### Testing- [ ] Unit tests- [ ] Integration tests- [ ] User acceptance testing
### Swarm Coordination- **Architect**: Design and planning- **Coder**: Implementation- **Tester**: Quality assurance- **Documenter**: Documentation
---🤖 Generated with Claude Code

Swarm Task Template

markdown
<!-- .github/ISSUE_TEMPLATE$swarm-task.yml -->name: Swarm Taskdescription: Create a task for AI swarm processingbody:  - type: dropdown    id: topology    attributes:      label: Swarm Topology      options:        - mesh        - hierarchical        - ring        - star  - type: input    id: agents    attributes:      label: Required Agents      placeholder: "coder, tester, analyst"  - type: textarea    id: tasks    attributes:      label: Task Breakdown      placeholder: |        1. Task one description        2. Task two description

Workflow Integration

GitHub Actions for Issue Management

yaml
# .github$workflows$issue-swarm.ymlname: Issue Swarm Handleron:  issues:    types: [opened, labeled, commented]
jobs:  swarm-process:    runs-on: ubuntu-latest    steps:      - name: Process Issue        uses: ruvnet$swarm-action@v1        with:          command: |            if [[ "${{ github.event.label.name }}" == "swarm-ready" ]]; then              npx ruv-swarm github issue-init ${{ github.event.issue.number }}            fi

Board Integration Workflow

bash
# Sync with project boardnpx ruv-swarm github issue-board-sync \  --project "Development" \  --column-mapping '{    "To Do": "pending",    "In Progress": "active",    "Done": "completed"  }'

Specialized Issue Strategies

Bug Investigation Swarm

bash
# Specialized bug handlingnpx ruv-swarm github bug-swarm 456 \  --reproduce \  --isolate \  --fix \  --test

Feature Implementation Swarm

bash
# Feature implementation swarmnpx ruv-swarm github feature-swarm 456 \  --design \  --implement \  --document \  --demo

Technical Debt Refactoring

bash
# Refactoring swarmnpx ruv-swarm github debt-swarm 456 \  --analyze-impact \  --plan-migration \  --execute \  --validate

Best Practices

1. Swarm-Coordinated Issue Management

  • Always initialize swarm for complex issues
  • Assign specialized agents based on issue type
  • Use memory for progress coordination
  • Regular automated progress updates

2. Board Organization

  • Clear column definitions with consistent naming
  • Systematic labeling strategy across repositories
  • Regular board grooming and maintenance
  • Well-defined automation rules

3. Data Integrity

  • Bidirectional sync validation
  • Conflict resolution strategies
  • Comprehensive audit trails
  • Regular backups of project data

4. Team Adoption

  • Comprehensive training materials
  • Clear, documented workflows
  • Regular team reviews and retrospectives
  • Active feedback loops for improvement

5. Smart Labeling and Organization

  • Consistent labeling strategy across repositories
  • Priority-based issue sorting and assignment
  • Milestone integration for project coordination
  • Agent-type to label mapping

6. Automated Progress Tracking

  • Regular automated updates with swarm coordination
  • Progress metrics and completion tracking
  • Cross-issue dependency management
  • Real-time status synchronization

Troubleshooting

Sync Issues

bash
# Diagnose sync problemsnpx ruv-swarm github board-diagnose \  --check "permissions,webhooks,rate-limits" \  --test-sync \  --show-conflicts

Performance Optimization

bash
# Optimize board performancenpx ruv-swarm github board-optimize \  --analyze-size \  --archive-completed \  --index-fields \  --cache-views

Data Recovery

bash
# Recover board datanpx ruv-swarm github board-recover \  --backup-id "2024-01-15" \  --restore-cards \  --preserve-current \  --merge-conflicts

Metrics & Analytics

Performance Metrics

Automatic tracking of:

  • Issue creation and resolution times
  • Agent productivity metrics
  • Project milestone progress
  • Cross-repository coordination efficiency
  • Sprint velocity and burndown
  • Cycle time and throughput
  • Work-in-progress limits

Reporting Features

  • Weekly progress summaries
  • Agent performance analytics
  • Project health metrics
  • Integration success rates
  • Team collaboration metrics
  • Quality and defect tracking

Issue Resolution Time

bash
# Analyze swarm performancenpx ruv-swarm github issue-metrics \  --issue 456 \  --metrics "time-to-close,agent-efficiency,subtask-completion"

Swarm Effectiveness

bash
# Generate effectiveness reportnpx ruv-swarm github effectiveness \  --issues "closed:>2024-01-01" \  --compare "with-swarm,without-swarm"

Security & Permissions

  1. Command Authorization: Validate user permissions before executing commands
  2. Rate Limiting: Prevent spam and abuse of issue commands
  3. Audit Logging: Track all swarm operations on issues and boards
  4. Data Privacy: Respect private repository settings
  5. Access Control: Proper GitHub permissions for board operations
  6. Webhook Security: Secure webhook endpoints for real-time updates

Integration with Other Skills

Seamless Integration With:

  • github-pr-workflow - Link issues to pull requests automatically
  • github-release-management - Coordinate release issues and milestones
  • sparc-orchestrator - Complex project coordination workflows
  • sparc-tester - Automated testing workflows for issues

Complete Workflow Example

Full-Stack Feature Development

bash
# 1. Create feature issue with swarm coordinationgh issue create \  --title "Feature: Real-time Collaboration" \  --body "$(cat <<EOF## Feature: Real-time Collaboration
### OverviewImplement real-time collaboration features using WebSockets.
### Objectives- [ ] WebSocket server setup- [ ] Client-side integration- [ ] Presence tracking- [ ] Conflict resolution- [ ] Testing and documentation
### Swarm CoordinationThis feature will use mesh topology for parallel development.EOF)" \  --label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasksISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')npx ruv-swarm github issue-init $ISSUE_NUM \  --topology mesh \  --auto-decompose \  --assign-agents "architect,coder,tester"
# 3. Add to project boardPROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')gh project item-add $PROJECT_ID --owner @me \  --url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated trackingnpx ruv-swarm github board-sync \  --auto-move-cards \  --update-metadata
# 5. Monitor progressnpx ruv-swarm github issue-progress $ISSUE_NUM \  --auto-update-comments \  --notify-on-completion

Quick Reference Commands

bash
# Issue Managementgh issue create --title "..." --body "..." --label "..."npx ruv-swarm github issue-init <number>npx ruv-swarm github issue-decompose <number>npx ruv-swarm github triage --unlabeled
# Project Boardsnpx ruv-swarm github board-init --project-id <id>npx ruv-swarm github board-syncnpx ruv-swarm github board-analytics
# Sprint Managementnpx ruv-swarm github sprint-manage --sprint "Sprint X"npx ruv-swarm github milestone-track --milestone "vX.X"
# Analyticsnpx ruv-swarm github issue-metrics --issue <number>npx ruv-swarm github board-kpis

Additional Resources

Last Updated: 2025-10-19 Version: 2.0.0 Maintainer: Claude Code

Source and attribution

Source:ruvnet/rufloin.agents/skills/github-project-managementat commit6051f67

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from ruvnet/ruflo

Cron Schedule

ruvnet

Schedules persistent background workers using CronCreate with recommended cron intervals for recurring tasks.

DevOps & Cloud74Kupdated today

Autopilot Predict

ruvnet

Predicts the next task to work on using Ruflo autopilot MCP tools and learned patterns.

AI & Agents74Kupdated today

Autopilot Loop

ruvnet

Runs one autonomous autopilot iteration: checks status, executes the predicted task, logs it, and schedules the next wake.

AI & Agents74Kupdated today

Worker Integration

ruvnet

Coordinates background workers with specialized agents, mapping triggers to agents and tracking performance.

AI & Agents74Kupdated today

Worker Benchmarks

ruvnet

Runs performance benchmarks for the agentic-flow worker system and reports latency, throughput and memory metrics.

Software Development74Kupdated today

Swarm Advanced

ruvnet

Guides advanced Claude Flow swarm orchestration patterns for research, development, testing and analysis workflows.

AI & Agents74Kupdated today

More in Productivity & Workflow

Dd Meeting Prep

anthropics

Featured

Prepares question lists, benchmarks and red flags for due diligence meetings such as management presentations and expert calls.

Productivity & Workflow39Kupdated 2 weeks ago

Dd Checklist

anthropics

Featured

Builds and tracks sector-tailored due diligence checklists with workstreams, status tracking and red flag escalation.

Productivity & Workflow39Kupdated 2 weeks ago

Deal Tracker

anthropics

Featured

Tracks live M&A deals with milestones, deadlines, action items and weekly pipeline reviews.

Productivity & Workflow39Kupdated 2 weeks ago

Client Review

anthropics

Featured

Prepares client review meetings with portfolio performance, allocation analysis, talking points, and action items.

Productivity & Workflow39Kupdated 2 weeks ago

Morning Note

anthropics

Featured

Drafts concise morning meeting notes on overnight developments, trade ideas and key events for coverage stocks.

Productivity & Workflow39Kupdated 2 weeks ago

Notion Spec To Implementation

openai

Featured

Turns Notion specs into implementation plans, linked tasks, and progress updates inside Notion.

Productivity & Workflow27Kupdated 4 weeks ago