euaziel/wifi-csi-human-pose-detection/performance-analysis

Name: performance-analysis
Author: euaziel

Claude Code and agent skill by euaziel/wifi-csi-human-pose-detection

Trust tier 2

community

By euaziel
Coding
euaziel/wifi-csi-human-pose-detection
vendor/ruvector/.claude/skills/performance-analysis/SKILL.md
Updated 27 Mar 2026
Version 1.0.01 version recorded

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 euaziel/wifi-csi-human-pose-detection/performance-analysis

SKILL.md

Performance Analysis Skill

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

🧠 Self-Learning Intelligence

Integrates with RuVector's Q-learning and vector memory for improved performance. CLI: node .claude/intelligence/cli.js stats

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

Executive Summary

Overall performance score
Key metrics overview
Critical findings

Swarm Overview

Topology configuration
Agent distribution
Task statistics

Performance Metrics

Execution times
Throughput analysis
Resource utilization
Latency breakdown

Bottleneck Analysis

Identified bottlenecks
Impact assessment
Optimization priorities

Comparative Analysis (when --compare used)

Performance trends
Improvement metrics
Regression detection

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

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 reviewPassed

See the full security report

Quality evaluation

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

See evaluation results

Source

SKILL.md in the repositoryCheckingvendor/ruvector/.claude/skills/performance-analysis/SKILL.md

Popularity

Repository stars: 60
Repository forks: 23
7-day trend score: 21

Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 18 Mar 2026, 7 months ago.

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](https://verified-skill.com/api/v1/skills/euaziel/wifi-csi-human-pose-detection/performance-analysis/badge)](https://verified-skill.com/skills/euaziel/wifi-csi-human-pose-detection/performance-analysis)

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