Swarm Advanced

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

Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows

Instructions onlyAI & Agents
AI-generated overview

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

What it does
This skill documents advanced swarm orchestration patterns built on Claude Flow MCP tools and CLI commands. It describes topologies (mesh, hierarchical, star, ring), agent strategies, and four end-to-end patterns: research, development, testing and analysis swarms. It also covers fault tolerance, memory and state management, neural pattern learning, workflow automation, performance optimization and monitoring, with code examples and troubleshooting notes.
When to use it
Use it when planning or running multi-agent Claude Flow swarms for distributed research, software development, testing or code analysis. It suits users who need topology selection guidance, agent role definitions and orchestration examples rather than a single-task prompt.
Requirements
Requires the Claude Flow CLI installed globally via npm (claude-flow@alpha) and, for MCP tool usage, the claude-flow MCP server added to the agent. Network access is needed for npm installation and referenced documentation. No scripts ship with the skill; it is instructions and code examples only.

Advanced Swarm Orchestration

Master advanced swarm patterns for distributed research, development, and testing workflows. This skill covers comprehensive orchestration strategies using both MCP tools and CLI commands.

Quick Start

Prerequisites

bash
# Ensure Claude Flow is installednpm install -g claude-flow@alpha
# Add MCP server (if using MCP tools)claude mcp add claude-flow npx claude-flow@alpha mcp start

Basic Pattern

javascript
// 1. Initialize swarm topologymcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })
// 2. Spawn specialized agentsmcp__claude-flow__agent_spawn({ type: "researcher", name: "Agent 1" })
// 3. Orchestrate tasksmcp__claude-flow__task_orchestrate({ task: "...", strategy: "parallel" })

Core Concepts

Swarm Topologies

Mesh Topology - Peer-to-peer communication, best for research and analysis

  • All agents communicate directly
  • High flexibility and resilience
  • Use for: Research, analysis, brainstorming

Hierarchical Topology - Coordinator with subordinates, best for development

  • Clear command structure
  • Sequential workflow support
  • Use for: Development, structured workflows

Star Topology - Central coordinator, best for testing

  • Centralized control and monitoring
  • Parallel execution with coordination
  • Use for: Testing, validation, quality assurance

Ring Topology - Sequential processing chain

  • Step-by-step processing
  • Pipeline workflows
  • Use for: Multi-stage processing, data pipelines

Agent Strategies

Adaptive - Dynamic adjustment based on task complexity Balanced - Equal distribution of work across agents Specialized - Task-specific agent assignment Parallel - Maximum concurrent execution

Pattern 1: Research Swarm

Purpose

Deep research through parallel information gathering, analysis, and synthesis.

Architecture

javascript
// Initialize research swarmmcp__claude-flow__swarm_init({  "topology": "mesh",  "maxAgents": 6,  "strategy": "adaptive"})
// Spawn research teamconst researchAgents = [  {    type: "researcher",    name: "Web Researcher",    capabilities: ["web-search", "content-extraction", "source-validation"]  },  {    type: "researcher",    name: "Academic Researcher",    capabilities: ["paper-analysis", "citation-tracking", "literature-review"]  },  {    type: "analyst",    name: "Data Analyst",    capabilities: ["data-processing", "statistical-analysis", "visualization"]  },  {    type: "analyst",    name: "Pattern Analyzer",    capabilities: ["trend-detection", "correlation-analysis", "outlier-detection"]  },  {    type: "documenter",    name: "Report Writer",    capabilities: ["synthesis", "technical-writing", "formatting"]  }]
// Spawn all agentsresearchAgents.forEach(agent => {  mcp__claude-flow__agent_spawn({    type: agent.type,    name: agent.name,    capabilities: agent.capabilities  })})

Research Workflow

Phase 1: Information Gathering
javascript
// Parallel information collectionmcp__claude-flow__parallel_execute({  "tasks": [    {      "id": "web-search",      "command": "search recent publications and articles"    },    {      "id": "academic-search",      "command": "search academic databases and papers"    },    {      "id": "data-collection",      "command": "gather relevant datasets and statistics"    },    {      "id": "expert-search",      "command": "identify domain experts and thought leaders"    }  ]})
// Store research findings in memorymcp__claude-flow__memory_usage({  "action": "store",  "key": "research-findings-" + Date.now(),  "value": JSON.stringify(findings),  "namespace": "research",  "ttl": 604800 // 7 days})
Phase 2: Analysis and Validation
javascript
// Pattern recognition in findingsmcp__claude-flow__pattern_recognize({  "data": researchData,  "patterns": ["trend", "correlation", "outlier", "emerging-pattern"]})
// Cognitive analysismcp__claude-flow__cognitive_analyze({  "behavior": "research-synthesis"})
// Quality assessmentmcp__claude-flow__quality_assess({  "target": "research-sources",  "criteria": ["credibility", "relevance", "recency", "authority"]})
// Cross-reference validationmcp__claude-flow__neural_patterns({  "action": "analyze",  "operation": "fact-checking",  "metadata": { "sources": sourcesArray }})
Phase 3: Knowledge Management
javascript
// Search existing knowledge basemcp__claude-flow__memory_search({  "pattern": "topic X",  "namespace": "research",  "limit": 20})
// Create knowledge graph connectionsmcp__claude-flow__neural_patterns({  "action": "learn",  "operation": "knowledge-graph",  "metadata": {    "topic": "X",    "connections": relatedTopics,    "depth": 3  }})
// Store connections for future usemcp__claude-flow__memory_usage({  "action": "store",  "key": "knowledge-graph-X",  "value": JSON.stringify(knowledgeGraph),  "namespace": "research/graphs",  "ttl": 2592000 // 30 days})
Phase 4: Report Generation
javascript
// Orchestrate report generationmcp__claude-flow__task_orchestrate({  "task": "generate comprehensive research report",  "strategy": "sequential",  "priority": "high",  "dependencies": ["gather", "analyze", "validate", "synthesize"]})
// Monitor research progressmcp__claude-flow__swarm_status({  "swarmId": "research-swarm"})
// Generate final reportmcp__claude-flow__workflow_execute({  "workflowId": "research-report-generation",  "params": {    "findings": findings,    "format": "comprehensive",    "sections": ["executive-summary", "methodology", "findings", "analysis", "conclusions", "references"]  }})

CLI Fallback

bash
# Quick research swarmnpx claude-flow swarm "research AI trends in 2025" \  --strategy research \  --mode distributed \  --max-agents 6 \  --parallel \  --output research-report.md

Pattern 2: Development Swarm

Purpose

Full-stack development through coordinated specialist agents.

Architecture

javascript
// Initialize development swarm with hierarchymcp__claude-flow__swarm_init({  "topology": "hierarchical",  "maxAgents": 8,  "strategy": "balanced"})
// Spawn development teamconst devTeam = [  { type: "architect", name: "System Architect", role: "coordinator" },  { type: "coder", name: "Backend Developer", capabilities: ["node", "api", "database"] },  { type: "coder", name: "Frontend Developer", capabilities: ["react", "ui", "ux"] },  { type: "coder", name: "Database Engineer", capabilities: ["sql", "nosql", "optimization"] },  { type: "tester", name: "QA Engineer", capabilities: ["unit", "integration", "e2e"] },  { type: "reviewer", name: "Code Reviewer", capabilities: ["security", "performance", "best-practices"] },  { type: "documenter", name: "Technical Writer", capabilities: ["api-docs", "guides", "tutorials"] },  { type: "monitor", name: "DevOps Engineer", capabilities: ["ci-cd", "deployment", "monitoring"] }]
// Spawn all team membersdevTeam.forEach(member => {  mcp__claude-flow__agent_spawn({    type: member.type,    name: member.name,    capabilities: member.capabilities,    swarmId: "dev-swarm"  })})

Development Workflow

Phase 1: Architecture and Design
javascript
// System architecture designmcp__claude-flow__task_orchestrate({  "task": "design system architecture for REST API",  "strategy": "sequential",  "priority": "critical",  "assignTo": "System Architect"})
// Store architecture decisionsmcp__claude-flow__memory_usage({  "action": "store",  "key": "architecture-decisions",  "value": JSON.stringify(architectureDoc),  "namespace": "development/design"})
Phase 2: Parallel Implementation
javascript
// Parallel development tasksmcp__claude-flow__parallel_execute({  "tasks": [    {      "id": "backend-api",      "command": "implement REST API endpoints",      "assignTo": "Backend Developer"    },    {      "id": "frontend-ui",      "command": "build user interface components",      "assignTo": "Frontend Developer"    },    {      "id": "database-schema",      "command": "design and implement database schema",      "assignTo": "Database Engineer"    },    {      "id": "api-documentation",      "command": "create API documentation",      "assignTo": "Technical Writer"    }  ]})
// Monitor development progressmcp__claude-flow__swarm_monitor({  "swarmId": "dev-swarm",  "interval": 5000})
Phase 3: Testing and Validation
javascript
// Comprehensive testingmcp__claude-flow__batch_process({  "items": [    { type: "unit", target: "all-modules" },    { type: "integration", target: "api-endpoints" },    { type: "e2e", target: "user-flows" },    { type: "performance", target: "critical-paths" }  ],  "operation": "execute-tests"})
// Quality assessmentmcp__claude-flow__quality_assess({  "target": "codebase",  "criteria": ["coverage", "complexity", "maintainability", "security"]})
Phase 4: Review and Deployment
javascript
// Code review workflowmcp__claude-flow__workflow_execute({  "workflowId": "code-review-process",  "params": {    "reviewers": ["Code Reviewer"],    "criteria": ["security", "performance", "best-practices"]  }})
// CI/CD pipelinemcp__claude-flow__pipeline_create({  "config": {    "stages": ["build", "test", "security-scan", "deploy"],    "environment": "production"  }})

CLI Fallback

bash
# Quick development swarmnpx claude-flow swarm "build REST API with authentication" \  --strategy development \  --mode hierarchical \  --monitor \  --output sqlite

Pattern 3: Testing Swarm

Purpose

Comprehensive quality assurance through distributed testing.

Architecture

javascript
// Initialize testing swarm with star topologymcp__claude-flow__swarm_init({  "topology": "star",  "maxAgents": 7,  "strategy": "parallel"})
// Spawn testing teamconst testingTeam = [  {    type: "tester",    name: "Unit Test Coordinator",    capabilities: ["unit-testing", "mocking", "coverage", "tdd"]  },  {    type: "tester",    name: "Integration Tester",    capabilities: ["integration", "api-testing", "contract-testing"]  },  {    type: "tester",    name: "E2E Tester",    capabilities: ["e2e", "ui-testing", "user-flows", "selenium"]  },  {    type: "tester",    name: "Performance Tester",    capabilities: ["load-testing", "stress-testing", "benchmarking"]  },  {    type: "monitor",    name: "Security Tester",    capabilities: ["security-testing", "penetration-testing", "vulnerability-scanning"]  },  {    type: "analyst",    name: "Test Analyst",    capabilities: ["coverage-analysis", "test-optimization", "reporting"]  },  {    type: "documenter",    name: "Test Documenter",    capabilities: ["test-documentation", "test-plans", "reports"]  }]
// Spawn all testerstestingTeam.forEach(tester => {  mcp__claude-flow__agent_spawn({    type: tester.type,    name: tester.name,    capabilities: tester.capabilities,    swarmId: "testing-swarm"  })})

Testing Workflow

Phase 1: Test Planning
javascript
// Analyze test coverage requirementsmcp__claude-flow__quality_assess({  "target": "test-coverage",  "criteria": [    "line-coverage",    "branch-coverage",    "function-coverage",    "edge-cases"  ]})
// Identify test scenariosmcp__claude-flow__pattern_recognize({  "data": testScenarios,  "patterns": [    "edge-case",    "boundary-condition",    "error-path",    "happy-path"  ]})
// Store test planmcp__claude-flow__memory_usage({  "action": "store",  "key": "test-plan-" + Date.now(),  "value": JSON.stringify(testPlan),  "namespace": "testing/plans"})
Phase 2: Parallel Test Execution
javascript
// Execute all test suites in parallelmcp__claude-flow__parallel_execute({  "tasks": [    {      "id": "unit-tests",      "command": "npm run test:unit",      "assignTo": "Unit Test Coordinator"    },    {      "id": "integration-tests",      "command": "npm run test:integration",      "assignTo": "Integration Tester"    },    {      "id": "e2e-tests",      "command": "npm run test:e2e",      "assignTo": "E2E Tester"    },    {      "id": "performance-tests",      "command": "npm run test:performance",      "assignTo": "Performance Tester"    },    {      "id": "security-tests",      "command": "npm run test:security",      "assignTo": "Security Tester"    }  ]})
// Batch process test suitesmcp__claude-flow__batch_process({  "items": testSuites,  "operation": "execute-test-suite"})
Phase 3: Performance and Security
javascript
// Run performance benchmarksmcp__claude-flow__benchmark_run({  "suite": "comprehensive-performance"})
// Bottleneck analysismcp__claude-flow__bottleneck_analyze({  "component": "application",  "metrics": ["response-time", "throughput", "memory", "cpu"]})
// Security scanningmcp__claude-flow__security_scan({  "target": "application",  "depth": "comprehensive"})
// Vulnerability analysismcp__claude-flow__error_analysis({  "logs": securityScanLogs})
Phase 4: Monitoring and Reporting
javascript
// Real-time test monitoringmcp__claude-flow__swarm_monitor({  "swarmId": "testing-swarm",  "interval": 2000})
// Generate comprehensive test reportmcp__claude-flow__performance_report({  "format": "detailed",  "timeframe": "current-run"})
// Get test resultsmcp__claude-flow__task_results({  "taskId": "test-execution-001"})
// Trend analysismcp__claude-flow__trend_analysis({  "metric": "test-coverage",  "period": "30d"})

CLI Fallback

bash
# Quick testing swarmnpx claude-flow swarm "test application comprehensively" \  --strategy testing \  --mode star \  --parallel \  --timeout 600

Pattern 4: Analysis Swarm

Purpose

Deep code and system analysis through specialized analyzers.

Architecture

javascript
// Initialize analysis swarmmcp__claude-flow__swarm_init({  "topology": "mesh",  "maxAgents": 5,  "strategy": "adaptive"})
// Spawn analysis specialistsconst analysisTeam = [  {    type: "analyst",    name: "Code Analyzer",    capabilities: ["static-analysis", "complexity-analysis", "dead-code-detection"]  },  {    type: "analyst",    name: "Security Analyzer",    capabilities: ["security-scan", "vulnerability-detection", "dependency-audit"]  },  {    type: "analyst",    name: "Performance Analyzer",    capabilities: ["profiling", "bottleneck-detection", "optimization"]  },  {    type: "analyst",    name: "Architecture Analyzer",    capabilities: ["dependency-analysis", "coupling-detection", "modularity-assessment"]  },  {    type: "documenter",    name: "Analysis Reporter",    capabilities: ["reporting", "visualization", "recommendations"]  }]
// Spawn all analystsanalysisTeam.forEach(analyst => {  mcp__claude-flow__agent_spawn({    type: analyst.type,    name: analyst.name,    capabilities: analyst.capabilities  })})

Analysis Workflow

javascript
// Parallel analysis executionmcp__claude-flow__parallel_execute({  "tasks": [    { "id": "analyze-code", "command": "analyze codebase structure and quality" },    { "id": "analyze-security", "command": "scan for security vulnerabilities" },    { "id": "analyze-performance", "command": "identify performance bottlenecks" },    { "id": "analyze-architecture", "command": "assess architectural patterns" }  ]})
// Generate comprehensive analysis reportmcp__claude-flow__performance_report({  "format": "detailed",  "timeframe": "current"})
// Cost analysismcp__claude-flow__cost_analysis({  "timeframe": "30d"})

Advanced Techniques

Error Handling and Fault Tolerance

javascript
// Setup fault tolerance for all agentsmcp__claude-flow__daa_fault_tolerance({  "agentId": "all",  "strategy": "auto-recovery"})
// Error handling patterntry {  await mcp__claude-flow__task_orchestrate({    "task": "complex operation",    "strategy": "parallel",    "priority": "high"  })} catch (error) {  // Check swarm health  const status = await mcp__claude-flow__swarm_status({})
  // Analyze error patterns  await mcp__claude-flow__error_analysis({    "logs": [error.message]  })
  // Auto-recovery attempt  if (status.healthy) {    await mcp__claude-flow__task_orchestrate({      "task": "retry failed operation",      "strategy": "sequential"    })  }}

Memory and State Management

javascript
// Cross-session persistencemcp__claude-flow__memory_persist({  "sessionId": "swarm-session-001"})
// Namespace management for different swarmsmcp__claude-flow__memory_namespace({  "namespace": "research-swarm",  "action": "create"})
// Create state snapshotmcp__claude-flow__state_snapshot({  "name": "development-checkpoint-1"})
// Restore from snapshot if neededmcp__claude-flow__context_restore({  "snapshotId": "development-checkpoint-1"})
// Backup memory storesmcp__claude-flow__memory_backup({  "path": "/workspaces/claude-code-flow/backups/swarm-memory.json"})

Neural Pattern Learning

javascript
// Train neural patterns from successful workflowsmcp__claude-flow__neural_train({  "pattern_type": "coordination",  "training_data": JSON.stringify(successfulWorkflows),  "epochs": 50})
// Adaptive learning from experiencemcp__claude-flow__learning_adapt({  "experience": {    "workflow": "research-to-report",    "success": true,    "duration": 3600,    "quality": 0.95  }})
// Pattern recognition for optimizationmcp__claude-flow__pattern_recognize({  "data": workflowMetrics,  "patterns": ["bottleneck", "optimization-opportunity", "efficiency-gain"]})

Workflow Automation

javascript
// Create reusable workflowmcp__claude-flow__workflow_create({  "name": "full-stack-development",  "steps": [    { "phase": "design", "agents": ["architect"] },    { "phase": "implement", "agents": ["backend-dev", "frontend-dev"], "parallel": true },    { "phase": "test", "agents": ["tester", "security-tester"], "parallel": true },    { "phase": "review", "agents": ["reviewer"] },    { "phase": "deploy", "agents": ["devops"] }  ],  "triggers": ["on-commit", "scheduled-daily"]})
// Setup automation rulesmcp__claude-flow__automation_setup({  "rules": [    {      "trigger": "file-changed",      "pattern": "*.js",      "action": "run-tests"    },    {      "trigger": "PR-created",      "action": "code-review-swarm"    }  ]})
// Event-driven triggersmcp__claude-flow__trigger_setup({  "events": ["code-commit", "PR-merge", "deployment"],  "actions": ["test", "analyze", "document"]})

Performance Optimization

javascript
// Topology optimizationmcp__claude-flow__topology_optimize({  "swarmId": "current-swarm"})
// Load balancingmcp__claude-flow__load_balance({  "swarmId": "development-swarm",  "tasks": taskQueue})
// Agent coordination syncmcp__claude-flow__coordination_sync({  "swarmId": "development-swarm"})
// Auto-scalingmcp__claude-flow__swarm_scale({  "swarmId": "development-swarm",  "targetSize": 12})

Monitoring and Metrics

javascript
// Real-time swarm monitoringmcp__claude-flow__swarm_monitor({  "swarmId": "active-swarm",  "interval": 3000})
// Collect comprehensive metricsmcp__claude-flow__metrics_collect({  "components": ["agents", "tasks", "memory", "performance"]})
// Health monitoringmcp__claude-flow__health_check({  "components": ["swarm", "agents", "neural", "memory"]})
// Usage statisticsmcp__claude-flow__usage_stats({  "component": "swarm-orchestration"})
// Trend analysismcp__claude-flow__trend_analysis({  "metric": "agent-performance",  "period": "7d"})

Best Practices

1. Choosing the Right Topology

  • Mesh: Research, brainstorming, collaborative analysis
  • Hierarchical: Structured development, sequential workflows
  • Star: Testing, validation, centralized coordination
  • Ring: Pipeline processing, staged workflows

2. Agent Specialization

  • Assign specific capabilities to each agent
  • Avoid overlapping responsibilities
  • Use coordination agents for complex workflows
  • Leverage memory for agent communication

3. Parallel Execution

  • Identify independent tasks for parallelization
  • Use sequential execution for dependent tasks
  • Monitor resource usage during parallel execution
  • Implement proper error handling

4. Memory Management

  • Use namespaces to organize memory
  • Set appropriate TTL values
  • Create regular backups
  • Implement state snapshots for checkpoints

5. Monitoring and Optimization

  • Monitor swarm health regularly
  • Collect and analyze metrics
  • Optimize topology based on performance
  • Use neural patterns to learn from success

6. Error Recovery

  • Implement fault tolerance strategies
  • Use auto-recovery mechanisms
  • Analyze error patterns
  • Create fallback workflows

Real-World Examples

Example 1: AI Research Project

javascript
// Research AI trends, analyze findings, generate reportmcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })// Spawn: 2 researchers, 2 analysts, 1 synthesizer, 1 documenter// Parallel gather → Analyze patterns → Synthesize → Report

Example 2: Full-Stack Application

javascript
// Build complete web application with testingmcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 8 })// Spawn: 1 architect, 2 devs, 1 db engineer, 2 testers, 1 reviewer, 1 devops// Design → Parallel implement → Test → Review → Deploy

Example 3: Security Audit

javascript
// Comprehensive security analysismcp__claude-flow__swarm_init({ topology: "star", maxAgents: 5 })// Spawn: 1 coordinator, 1 code analyzer, 1 security scanner, 1 penetration tester, 1 reporter// Parallel scan → Vulnerability analysis → Penetration test → Report

Example 4: Performance Optimization

javascript
// Identify and fix performance bottlenecksmcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 4 })// Spawn: 1 profiler, 1 bottleneck analyzer, 1 optimizer, 1 tester// Profile → Identify bottlenecks → Optimize → Validate

Troubleshooting

Common Issues

Issue: Swarm agents not coordinating properly Solution: Check topology selection, verify memory usage, enable monitoring

Issue: Parallel execution failing Solution: Verify task dependencies, check resource limits, implement error handling

Issue: Memory persistence not working Solution: Verify namespaces, check TTL settings, ensure backup configuration

Issue: Performance degradation Solution: Optimize topology, reduce agent count, analyze bottlenecks

Related Skills

  • sparc-methodology - Systematic development workflow
  • github-integration - Repository management and automation
  • neural-patterns - AI-powered coordination optimization
  • memory-management - Cross-session state persistence

References

Version: 2.0.0 Last Updated: 2025-10-19 Skill Level: Advanced Estimated Learning Time: 2-3 hours

Source and attribution

Source:ruvnet/rufloin.claude/skills/swarm-advancedat commit60de638

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

Stream Chain

ruvnet

Orchestrates multi-step agent workflows where each step's output feeds the next, via custom chains or predefined pipelines.

AI & Agents74Kupdated today

More in AI & Agents

Ppt Template Creator

anthropics

Featured

Turns a user's PowerPoint template into a reusable skill that generates branded presentations.

AI & Agents39Kupdated 2 weeks ago

Skill Development

anthropics

Featured

Guides creation of Claude Code plugin skills, covering structure, descriptions, progressive disclosure and validation.

AI & Agents37Kupdated today

Plugin Structure

anthropics

Featured

Guides the structure, manifest, and component layout of Claude Code plugins.

AI & Agents37Kupdated today

Command Development

anthropics

Featured

Guides creation of Claude Code slash commands, covering structure, YAML frontmatter, arguments and plugin features.

AI & Agents37Kupdated today

Claude Md Improver

anthropics

Featured

Audits CLAUDE.md files in a repository, scores their quality, and applies approved targeted improvements.

AI & Agents37Kupdated today

Find Skills

vercel-labs

Featured

Guides discovery, quality checking and installation of agent skills via the npx skills CLI.

AI & Agents33Kupdated today