alphasaleaidan/opus-5-5-x-gpt-skill-tree/performance-analysis

Claude Code and agent skill by alphasaleaidan/opus-5-5-x-gpt-skill-tree

Trust tier 2
  • community
LLM review pending
Source check pending

Checking that the SKILL.md file is still in the repository.

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms

Install

npx vskill@latest install alphasaleaidan/opus-5-5-x-gpt-skill-tree/performance-analysis

SKILL.md

The same SKILL.md was published earlier as alphasaleaidan/opus-5-5-x-gpt-skill-tree/performance-analysis.

Performance Analysis Skill

Comprehensive performance analysis suite for identifying bottlenecks, profiling swarm operations, generating detailed reports, and providing actionable optimization recommendations.

Overview

This skill consolidates all performance analysis capabilities:

  • Bottleneck Detection: Identify performance bottlenecks across communication, processing, memory, and network
  • Performance Profiling: Real-time monitoring and historical analysis of swarm operations
  • Report Generation: Create comprehensive performance reports in multiple formats
  • Optimization Recommendations: AI-powered suggestions for improving performance

Quick Start

Basic Bottleneck Detection
bash
npx claude-flow bottleneck detect
Generate Performance Report
bash
npx claude-flow analysis performance-report --format html --include-metrics
Analyze and Auto-Fix
bash
npx claude-flow bottleneck detect --fix --threshold 15

Core Capabilities

1. Bottleneck Detection
Command Syntax
bash
npx claude-flow bottleneck detect [options]
Options
  • --swarm-id, -s <id> - Analyze specific swarm (default: current)
  • --time-range, -t <range> - Analysis period: 1h, 24h, 7d, all (default: 1h)
  • --threshold <percent> - Bottleneck threshold percentage (default: 20)
  • --export, -e <file> - Export analysis to file
  • --fix - Apply automatic optimizations
Usage Examples
bash
# Basic detection for current swarm
npx claude-flow bottleneck detect
# Analyze specific swarm over 24 hours
npx claude-flow bottleneck detect --swarm-id swarm-123 -t 24h
# Export detailed analysis
npx claude-flow bottleneck detect -t 24h -e bottlenecks.json
# Auto-fix detected issues
npx claude-flow bottleneck detect --fix --threshold 15
# Low threshold for sensitive detection
npx claude-flow bottleneck detect --threshold 10 --export critical-issues.json
Metrics Analyzed

Communication Bottlenecks:

  • Message queue delays
  • Agent response times
  • Coordination overhead
  • Memory access patterns
  • Inter-agent communication latency

Processing Bottlenecks:

  • Task completion times
  • Agent utilization rates
  • Parallel execution efficiency
  • Resource contention
  • CPU/memory usage patterns

Memory Bottlenecks:

  • Cache hit rates
  • Memory access patterns
  • Storage I/O performance
  • Neural pattern loading times
  • Memory allocation efficiency

Network Bottlenecks:

  • API call latency
  • MCP communication delays
  • External service timeouts
  • Concurrent request limits
  • Network throughput issues
Output Format
🔍 Bottleneck Analysis Report
━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 Summary
├── Time Range: Last 1 hour
├── Agents Analyzed: 6
├── Tasks Processed: 42
└── Critical Issues: 2
🚨 Critical Bottlenecks
1. Agent Communication (35% impact)
└── coordinator → coder-1 messages delayed by 2.3s avg
2. Memory Access (28% impact)
└── Neural pattern loading taking 1.8s per access
⚠️ Warning Bottlenecks
1. Task Queue (18% impact)
└── 5 tasks waiting > 10s for assignment
💡 Recommendations
1. Switch to hierarchical topology (est. 40% improvement)
2. Enable memory caching (est. 25% improvement)
3. Increase agent concurrency to 8 (est. 20% improvement)
✅ Quick Fixes Available
Run with --fix to apply:
- Enable smart caching
- Optimize message routing
- Adjust agent priorities
2. Performance Profiling
Real-time Detection

Automatic analysis during task execution:

  • Execution time vs. complexity
  • Agent utilization rates
  • Resource constraints
  • Operation patterns
Common Bottleneck Patterns

Time Bottlenecks:

  • Tasks taking > 5 minutes
  • Sequential operations that could parallelize
  • Redundant file operations
  • Inefficient algorithm implementations

Coordination Bottlenecks:

  • Single agent for complex tasks
  • Unbalanced agent workloads
  • Poor topology selection
  • Excessive synchronization points

Resource Bottlenecks:

  • High operation count (> 100)
  • Memory constraints
  • I/O limitations
  • Thread pool saturation
MCP Integration
javascript
// Check for bottlenecks in Claude Code
mcp__claude-flow__bottleneck_detect({
timeRange: "1h",
threshold: 20,
autoFix: false
})
// Get detailed task results with bottleneck analysis
mcp__claude-flow__task_results({
taskId: "task-123",
format: "detailed"
})

Result Format:

json
{
"bottlenecks": [
{
"type": "coordination",
"severity": "high",
"description": "Single agent used for complex task",
"recommendation": "Spawn specialized agents for parallel work",
"impact": "35%",
"affectedComponents": ["coordinator", "coder-1"]
}
],
"improvements": [
{
"area": "execution_time",
"suggestion": "Use parallel task execution",
"expectedImprovement": "30-50% time reduction",
"implementationSteps": [
"Split task into smaller units",
"Spawn 3-4 specialized agents",
"Use mesh topology for coordination"
]
}
],
"metrics": {
"avgExecutionTime": "142s",
"agentUtilization": "67%",
"cacheHitRate": "82%",
"parallelizationFactor": 1.2
}
}
3. Report Generation
Command Syntax
bash
npx claude-flow analysis performance-report [options]
Options
  • --format <type> - Report format: json, html, markdown (default: markdown)
  • --include-metrics - Include detailed metrics and charts
  • --compare <id> - Compare with previous swarm
  • --time-range <range> - Analysis period: 1h, 24h, 7d, 30d, all
  • --output <file> - Output file path
  • --sections <list> - Comma-separated sections to include
Report Sections
  1. Executive Summary
  • Overall performance score
  • Key metrics overview
  • Critical findings
  1. Swarm Overview
  • Topology configuration
  • Agent distribution
  • Task statistics
  1. Performance Metrics
  • Execution times
  • Throughput analysis
  • Resource utilization
  • Latency breakdown
  1. Bottleneck Analysis
  • Identified bottlenecks
  • Impact assessment
  • Optimization priorities
  1. Comparative Analysis (when --compare used)
  • Performance trends
  • Improvement metrics
  • Regression detection
  1. Recommendations
  • Prioritized action items
  • Expected improvements
  • Implementation guidance
Usage Examples
bash
# Generate HTML report with all metrics
npx claude-flow analysis performance-report --format html --include-metrics
# Compare current swarm with previous
npx claude-flow analysis performance-report --compare swarm-123 --format markdown
# Custom output with specific sections
npx claude-flow analysis performance-report \
--sections summary,metrics,recommendations \
--output reports/perf-analysis.html \
--format html
# Weekly performance report
npx claude-flow analysis performance-report \
--time-range 7d \
--include-metrics \
--format markdown \
--output docs/weekly-performance.md
# JSON format for CI/CD integration
npx claude-flow analysis performance-report \
--format json \
--output build/performance.json
Sample Markdown Report
markdown
# Performance Analysis Report
## Executive Summary
-**Overall Score**: 87/100
-**Analysis Period**: Last 24 hours
-**Swarms Analyzed**: 3
-**Critical Issues**: 1
## Key Metrics
| Metric | Value | Trend | Target |
|--------|-------|-------|--------|
| Avg Task Time | 42s | ↓ 12% | 35s |
| Agent Utilization | 78% | ↑ 5% | 85% |
| Cache Hit Rate | 91% | → | 90% |
| Parallel Efficiency | 2.3x | ↑ 0.4x | 2.5x |
## Bottleneck Analysis
### Critical
1.**Agent Communication Delay** (Impact: 35%)
-Coordinator → Coder messages delayed by 2.3s avg
-**Fix**: Switch to hierarchical topology
### Warnings
1.**Memory Access Pattern** (Impact: 18%)
-Neural pattern loading: 1.8s per access
-**Fix**: Enable memory caching
## Recommendations
1.**High Priority**: Switch to hierarchical topology (40% improvement)
2.**Medium Priority**: Enable memory caching (25% improvement)
3.**Low Priority**: Increase agent concurrency to 8 (20% improvement)
4. Optimization Recommendations
Automatic Fixes

When using --fix, the following optimizations may be applied:

1. Topology Optimization

  • Switch to more efficient topology (mesh → hierarchical)
  • Adjust communication patterns
  • Reduce coordination overhead
  • Optimize message routing

2. Caching Enhancement

  • Enable memory caching
  • Optimize cache strategies
  • Preload common patterns
  • Implement cache warming

3. Concurrency Tuning

  • Adjust agent counts
  • Optimize parallel execution
  • Balance workload distribution
  • Implement load balancing

4. Priority Adjustment

  • Reorder task queues
  • Prioritize critical paths
  • Reduce wait times
  • Implement fair scheduling

5. Resource Optimization

  • Optimize memory usage
  • Reduce I/O operations
  • Batch API calls
  • Implement connection pooling
Performance Impact

Typical improvements after bottleneck resolution:

  • Communication: 30-50% faster message delivery
  • Processing: 20-40% reduced task completion time
  • Memory: 40-60% fewer cache misses
  • Network: 25-45% reduced API latency
  • Overall: 25-45% total performance improvement

Advanced Usage

Continuous Monitoring
bash
# Monitor performance in real-time
npx claude-flow swarm monitor --interval 5
# Generate hourly reports
while true; do
npx claude-flow analysis performance-report \
--format json \
--output logs/perf-$(date +%Y%m%d-%H%M).json
sleep 3600
done
CI/CD Integration
yaml
# .github/workflows/performance.yml
name: Performance Analysis
on: [push, pull_request]
jobs:
analyze:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run Performance Analysis
run: |
npx claude-flow analysis performance-report \
--format json \
--output performance.json
- name: Check Performance Thresholds
run: |
npx claude-flow bottleneck detect \
--threshold 15 \
--export bottlenecks.json
- name: Upload Reports
uses: actions/upload-artifact@v2
with:
name: performance-reports
path: |
performance.json
bottlenecks.json
Custom Analysis Scripts
javascript
// scripts/analyze-performance.js
const { exec } = require('child_process');
const fs = require('fs');
async function analyzePerformance() {
// Run bottleneck detection
const bottlenecks = await runCommand(
'npx claude-flow bottleneck detect --format json'
);
// Generate performance report
const report = await runCommand(
'npx claude-flow analysis performance-report --format json'
);
// Analyze results
const analysis = {
bottlenecks: JSON.parse(bottlenecks),
performance: JSON.parse(report),
timestamp: new Date().toISOString()
};
// Save combined analysis
fs.writeFileSync(
'analysis/combined-report.json',
JSON.stringify(analysis, null, 2)
);
// Generate alerts if needed
if (analysis.bottlenecks.critical.length > 0) {
console.error('CRITICAL: Performance bottlenecks detected!');
process.exit(1);
}
}
function runCommand(cmd) {
return new Promise((resolve, reject) => {
exec(cmd, (error, stdout, stderr) => {
if (error) reject(error);
else resolve(stdout);
});
});
}
analyzePerformance().catch(console.error);

Best Practices

1. Regular Analysis
  • Run bottleneck detection after major changes
  • Generate weekly performance reports
  • Monitor trends over time
  • Set up automated alerts
2. Threshold Tuning
  • Start with default threshold (20%)
  • Lower for production systems (10-15%)
  • Higher for development (25-30%)
  • Adjust based on requirements

This is the start of the file. Read the full SKILL.md on GitHub.

Security

  • Security scanPassed, 100 of 100Pattern checks on the skill's files.
  • Model reviewNot runA model review is scheduled for the next rescan.

Quality evaluation

  • Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

Source

Popularity

Repository stars
1
7-day trend score
8

Stars and forks are for the whole GitHub repository, not this skill alone. Not refreshed yet.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/alphasaleaidan/opus-5-5-x-gpt-skill-tree/performance-analysis/badge)](https://verified-skill.com/skills/alphasaleaidan/opus-5-5-x-gpt-skill-tree/performance-analysis)

Something wrong with this skill or its page? Tell us.