Swarm Advanced

ruvnet/ruflo/v3/@claude-flow/cli/.claude/skills/swarm-advanced

作者 ruvnet5f709e36799274be6bb68fff69090bdbc8621220無授權條款74K 個星標收錄於 2026年10月9日更新於 2026年10月9日儲存庫今天更新

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

僅含說明AI & Agents
AI 產生的概覽

記錄 Claude Flow 進階叢集編排模式，用於研究、開發、測試與分析工作流程。

功能
提供使用 Claude Flow 編排多代理叢集的參考模式，涵蓋 mesh、hierarchical、star 與 ring 拓撲，以及 adaptive、balanced、specialized、parallel 等代理策略。它依序說明研究、開發、測試與分析四種模式，列出代理陣容、分階段工作流程，以及用於產生代理、編排任務、儲存記憶與產生報告的 MCP 工具呼叫。也介紹容錯、記憶與狀態管理、神經模式學習、工作流程自動化、效能最佳化與監控等進階技巧，並附上 CLI 備用指令與疑難排解說明。
適用情境
適用於規劃或執行以 Claude Flow 為基礎的分散式多代理工作流程，例如平行研究與綜合、協同全端開發、分散式測試執行或程式碼庫分析。也適合在選擇叢集拓撲或代理策略，或為現有叢集加入監控、記憶持久化與錯誤復原時使用。
執行需求
需要以 npm 全域安裝 Claude Flow 套件（claude-flow@alpha）；若使用 MCP 工具，還需向代理註冊 claude-flow MCP 伺服器。安裝與 CLI 呼叫需要網路存取。此技能不附帶指令碼，只有說明與程式碼範例。

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/cli@latest 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/cli@latest 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/cli@latest 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

來源與署名

來源：ruvnet/ruflo位於v3/@claude-flow/cli/.claude/skills/swarm-advanced提交5f709e3

授權條款： 無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

更多來自 ruvnet/ruflo 的技能

Sparc Methodology

ruvnet

依 SPARC 階段引導軟體開發：規格說明、虛擬碼、架構、精煉、完成。

Software Development74K今天更新

Performance Analysis

ruvnet

指導效能剖析、基準測試與最佳化，並強調可重現的量測實務。

Software Development74K今天更新

Stream Chain

ruvnet

編排多步驟代理工作流程，讓每一步的輸出流入下一步，支援自訂鏈與預先定義的管線。

AI & Agents74K今天更新

Sparc Methodology

ruvnet

介紹 SPARC 軟體開發方法論及其 17 種 Claude Flow 多代理模式。

Software Development74K今天更新

Github Workflow Automation

ruvnet

指導使用 AI 叢集協調、工作流程範本和儲存庫管理指令來自動化 GitHub Actions CI/CD。

DevOps & Cloud74K今天更新

Github Release Management

ruvnet

編排 GitHub 軟體發佈：版本管理、變更日誌、建置、分階段部署與回復。

DevOps & Cloud74K今天更新

更多AI & Agents技能

Ppt Template Creator

anthropics

精選

將使用者的 PowerPoint 範本轉換為可重用的技能，用來產生品牌簡報。

AI & Agents39K2 週前更新

Skill Development

anthropics

精選

指導建立 Claude Code 外掛技能，涵蓋結構、描述、漸進式揭露與驗證。

AI & Agents37K今天更新

Plugin Structure

anthropics

精選

說明 Claude Code 外掛的結構、資訊清單與元件配置方式。

AI & Agents37K今天更新

Command Development

anthropics

精選

指導建立 Claude Code 斜線命令，涵蓋結構、YAML frontmatter、參數與外掛功能。

AI & Agents37K今天更新

Claude Md Improver

anthropics

精選

稽核儲存庫中的 CLAUDE.md 檔案、評估其品質，並在取得核准後套用針對性的改進。

AI & Agents37K今天更新

Find Skills

vercel-labs

精選

指導透過 npx skills 命令列工具探索、評估並安裝代理技能。

AI & Agents33K今天更新