
Rapidly creates atomic, focused skills optimized with evidence-based prompting, specialist agents, and systematic testing. Each micro-skill does one thing exceptionally well using self-consistency, program-of-thought, and plan-and-solve patterns. Enhanced with agent-creator principles and functionality-audit validation. Perfect for building composable workflow components.
Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Use when building RAG systems, semantic search engines, or intelligent knowledge bases.
Creates specialized AI agents with optimized system prompts using the official 4-phase SOP methodology from Desktop .claude-flow, combined with evidence-based prompting techniques and Claude Agent SDK implementation. Use this skill when creating production-ready agents for specific domains, workflows, or tasks requiring consistent high-quality performance with deeply embedded domain knowledge.
Implement persistent memory patterns for AI agents using AgentDB. Includes session memory, long-term storage, pattern learning, and context management. Use when building stateful agents, chat systems, or intelligent assistants.
Creates sophisticated workflow cascades coordinating multiple micro-skills with sequential pipelines, parallel execution, conditional branching, and Codex sandbox iteration. Enhanced with multi-model routing (Gemini/Codex), ruv-swarm coordination, memory persistence, and audit-pipeline patterns for production workflows.
Complete feature development lifecycle from research to deployment. Uses Gemini Search for best practices, architecture design, Codex prototyping, comprehensive testing, and documentation generation. Full 12-stage workflow.
Comprehensive GitHub code review with AI-powered swarm coordination
Advanced intent interpretation system that analyzes user requests using cognitive science principles and extrapolates logical volition. Use when user requests are ambiguous, when deeper understanding would improve response quality, or when helping users clarify what they truly need. Applies probabilistic intent mapping, first principles decomposition, and Socratic clarification to transform vague requests into well-understood goals.
Use Claude Code's interactive question tool to gather comprehensive requirements through structured multi-select questions
AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing. Supports TDD, debugging, refactoring, and learning sessions. Features automatic role switching, continuous code review, security scanning, and performance optimization with truth-score verification.
Comprehensive pre-deployment validation ensuring code is production-ready. Runs complete audit pipeline, performance benchmarks, security scan, documentation check, and generates deployment checklist.
Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems.
Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement. Use when building self-learning agents, optimizing workflows, or implementing meta-cognitive systems.
Loop 1 of the Three-Loop Integrated Development System. Research-driven requirements analysis with iterative risk mitigation through 5x pre-mortem cycles using multi-agent consensus. Feeds validated, risk-mitigated plans to parallel-swarm-implementation. Use when starting new features or projects requiring comprehensive planning with <3% failure confidence and evidence-based technology selection.
Configure Claude Code sandbox security with file system and network isolation boundaries
Create new Claude Code Skills with proper YAML frontmatter, progressive disclosure structure, and complete directory organization. Use when you need to build custom skills for specific workflows, generate skill templates, or understand the Claude Skills specification.
Creates ergonomic slash commands (/command) that provide fast, unambiguous access to micro-skills, cascades, and agents. Enhanced with auto-discovery, intelligent routing, parameter validation, and command chaining. Generates comprehensive command catalogs for all installed skills with multi-model integration.
Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
Audits code against CI/CD style rules, quality guidelines, and best practices, then rewrites code to meet standards without breaking functionality. Use this skill after functionality validation to ensure code is not just correct but also maintainable, readable, and production-ready. The skill applies linting rules, enforces naming conventions, improves code organization, and refactors for clarity while preserving all behavioral correctness verified by functionality audits.
Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems.
Performs comprehensive audits to detect placeholder code, mock data, TODO markers, and incomplete implementations in codebases. Use this skill when you need to find all instances of "theater" in code such as hardcoded mock responses, stub functions, commented-out production logic, or fake data that needs to be replaced with real implementations. The skill systematically identifies these instances, reads their full context, and completes them with production-quality code.
Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability.
Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms
Analyze skill library to identify coverage gaps, redundant overlaps, optimization opportunities, and provide recommendations for skill portfolio improvement
# Debugging Assistant Skill ## Overview Intelligent debugging workflow that systematically identifies symptoms, performs root cause analysis, generates fixes with explanations, validates solutions, and prevents regressions through comprehensive testing. ## Metadata - **Skill ID:** `when-debugging-code-use-debugging-assistant` - **Category:** Development/Debugging - **Complexity:** HIGH - **Agents Required:** coder, code-analyzer, tester - **Prerequisites:** Access to codebase, error logs, te
Specialized ML model development, training, and deployment workflow
Automated comprehensive code documentation generation with API docs, README files, inline comments, and architecture diagrams
# Interactive Requirements Planning SOP ```yaml metadata: skill_name: when-gathering-requirements-use-interactive-planner version: 1.0.0 category: specialized-tools difficulty: beginner estimated_duration: 15-30 minutes trigger_patterns: - "gather requirements" - "interactive questions" - "requirements gathering" - "clarify requirements" agents: - planner - researcher - system-architect success_criteria: - Requirements gathered - Specification
Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement
Active diagnostic tool for analyzing prompt quality, detecting anti-patterns, identifying token waste, and providing optimization recommendations
Comprehensive GitHub pull request code review using multi-agent swarm with specialized reviewers for security, performance, style, tests, and documentation. Coordinates security-auditor, perf-analyzer, code-analyzer, tester, and reviewer agents through mesh topology for parallel analysis. Provides detailed feedback with auto-fix suggestions and merge readiness assessment. Use when reviewing PRs, conducting code audits, or ensuring code quality standards before merge.
# Flow Nexus Platform Management SOP ```yaml metadata: skill_name: when-using-flow-nexus-platform-use-flow-nexus-platform version: 1.0.0 category: platform-integration difficulty: intermediate estimated_duration: 30-60 minutes trigger_patterns: - "flow nexus platform" - "manage flow nexus" - "flow nexus authentication" - "deploy to flow nexus" - "flow nexus sandboxes" dependencies: - flow-nexus MCP server - Valid email for registration - Claude Flow
Intelligent bug fixing workflow combining root cause analysis, multi-model reasoning, Codex auto-fix, and comprehensive testing. Uses RCA agent, Codex iteration, and validation to systematically fix bugs.
# Sandbox Security Configuration SOP ```yaml metadata: skill_name: when-configuring-sandbox-security-use-sandbox-configurator version: 1.0.0 category: specialized-tools difficulty: intermediate estimated_duration: 20-40 minutes trigger_patterns: - "configure sandbox security" - "sandbox isolation" - "file system boundaries" - "sandbox permissions" - "secure sandbox" dependencies: - Claude Code sandbox environment - Admin/root access (if applicable) ag
Code style and conventions audit with auto-fix capabilities for comprehensive style enforcement
# Testing Framework Skill - Complete SOP ## Metadata - **Skill ID**: when-testing-code-use-testing-framework - **Version**: 1.0.0 - **Category**: Testing - **Complexity**: HIGH - **Agents Required**: tester, coder, code-analyzer - **Estimated Time**: 2-4 hours ## Purpose Implement comprehensive testing infrastructure following industry best practices with proper test strategy, unit tests, integration tests, E2E tests, coverage analysis, and CI/CD integration. ## Trigger Conditions Activate
Comprehensive framework for analyzing, creating, and refining prompts for AI systems using evidence-based techniques
Loop 2 of the Three-Loop Integrated Development System. META-SKILL that dynamically compiles Loop 1 plans into agent+skill execution graphs. Queen Coordinator selects optimal agents from 86-agent registry and assigns skills (when available) or custom instructions. 9-step swarm with theater detection and reality validation. Receives plans from research-driven-planning, feeds to cicd-intelligent-recovery. Use for adaptive, theater-free implementation.
Comprehensive PR review with multi-agent swarm specialization for security, performance, style, tests, and documentation
Create new Claude Code Skills with proper YAML frontmatter, progressive disclosure structure, and complete directory organization
Enterprise-grade PowerPoint deck generation using evidence-based prompting, workflow enforcement, constraint-based design
Advanced intent interpretation system using cognitive science principles and probabilistic intent mapping
Validates that code actually works through sandbox testing, execution verification, and systematic debugging. Use this skill after code generation or modification to ensure functionality is genuine rather than assumed. The skill creates isolated test environments, executes code with realistic inputs, identifies bugs through systematic analysis, and applies best practices to fix issues without breaking existing functionality.
Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows
# Network Security Setup SOP ```yaml metadata: skill_name: when-setting-network-security-use-network-security-setup version: 1.0.0 category: specialized-tools difficulty: intermediate estimated_duration: 25-45 minutes trigger_patterns: - "network security" - "configure network isolation" - "trusted domains" - "firewall rules" - "network access control" dependencies: - Claude Code sandbox - Network configuration access agents: - security-manager
SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration
Comprehensive code review workflow coordinating quality, security, performance, and documentation reviewers. 4-hour timeline for thorough multi-agent review.
Complete REST API development workflow coordinating backend, database, testing, documentation, and DevOps agents. 2-week timeline with TDD approach.
Advanced skill creation system for Claude Code that combines deep intent analysis, evidence-based prompting principles, and systematic skill engineering. Use when creating new skills or refining existing skills to ensure they are well-structured, follow best practices, and incorporate sophisticated prompt engineering techniques. This skill transforms skill creation from template filling into a strategic design process.
Creates Claude Code skills where each skill is tied to a specialist agent optimized with evidence-based prompting techniques. Use this skill when users need to create reusable skills that leverage specialized agents for consistent high-quality performance. The skill ensures that each created skill spawns an appropriately crafted agent that communicates effectively with the parent Claude Code instance using best practices.
# Flow Nexus Cloud Swarm Deployment SOP ```yaml metadata: skill_name: when-deploying-cloud-swarm-use-flow-nexus-swarm version: 1.0.0 category: platform-integration difficulty: advanced estimated_duration: 40-70 minutes trigger_patterns: - "deploy cloud swarm" - "flow nexus swarm" - "distributed workflow" - "event-driven agents" - "cloud agent coordination" dependencies: - flow-nexus MCP server - Claude Flow hooks - E2B account (optional) agents:
Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms
# ML Training Debugger **Version**: 1.0.0 **Type**: Agent-based skill with SDK implementation **Domain**: Machine learning training diagnostics ## Description Diagnose machine learning training failures including loss divergence, mode collapse, gradient issues, architecture problems, and optimization failures. This skill spawns a specialist ML debugging agent that systematically analyzes training artifacts to identify root causes and propose evidence-based fixes. Use this skill when encounte
Automate internationalization and localization workflows for web applications with translation, key generation, and library setup
Automated coordination, formatting, and learning from Claude Code operations using intelligent hooks with MCP integration. Includes pre/post task hooks, session management, Git integration, memory coordination, and neural pattern training for enhanced development workflows.
Advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with consensus mechanisms and persistent memory
Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management
Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management
Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning
Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning. Coordinates planner, issue-tracker, and project-board-sync agents to automate issue triage, sprint planning, milestone tracking, and project board updates. Integrates with GitHub Projects v2 API for advanced automation, custom fields, and workflow orchestration. Use when managing development projects, coordinating team workflows, or automating project management tasks.
Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform
Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges
Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus
Comprehensive PR review using multi-agent swarm with specialized reviewers for security, performance, style, tests, and documentation. Provides detailed feedback with auto-fix suggestions and merge readiness assessment.
Loop 3 of the Three-Loop Integrated Development System. CI/CD automation with intelligent failure recovery, root cause analysis, and comprehensive quality validation. Receives implementation from Loop 2, feeds failure patterns back to Loop 1. Achieves 100% test success through automated repair and theater validation. v2.0.0 with explicit agent SOPs.
--- skill_id: when-training-rl-agents-use-agentdb-learning name: AgentDB Reinforcement Learning Training version: 1.0.0 category: agentdb subcategory: machine-learning trigger_pattern: "when-training-rl-agents" agents: - ml-developer - safla-neural - performance-benchmarker complexity: advanced estimated_duration: 6-10 hours prerequisites: - AgentDB basics - Reinforcement learning fundamentals - Neural network knowledge - Python/TypeScript proficiency outputs: - Trained RL agents
--- skill_id: when-building-semantic-search-use-agentdb-vector-search name: AgentDB Semantic Vector Search version: 1.0.0 category: agentdb subcategory: semantic-search trigger_pattern: "when-building-semantic-search" agents: - ml-developer - backend-dev - tester complexity: intermediate estimated_duration: 6-8 hours prerequisites: - AgentDB basics - Embedding models knowledge - REST API development outputs: - Semantic search engine - Document retrieval system - RAG-ready infra
Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations. Use when optimizing memory usage, improving search speed, or scaling to millions of vectors.
Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms. Includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more. Use when building self-learning agents, implementing RL, or optimizing agent behavior through experience.
Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, hybrid search, and distributed systems integration. Use when building distributed AI systems, multi-agent coordination, or advanced vector search applications.
Detects non-functional "theater" code that appears complete but doesn't actually work. Use this skill to identify code that looks correct in static analysis but fails during execution, preventing fake implementations from reaching production. Scans for suspicious patterns, validates actual functionality, and reports findings with recommendations.
--- skill_id: when-using-advanced-vector-search-use-agentdb-advanced name: Advanced AgentDB Vector Search Implementation version: 1.0.0 category: agentdb subcategory: distributed-systems trigger_pattern: "when-using-advanced-vector-search" agents: - ml-developer - backend-dev - performance-analyzer complexity: advanced estimated_duration: 8-12 hours prerequisites: - Basic AgentDB knowledge - Vector database concepts - Distributed systems understanding - TypeScript/Node.js proficien
--- skill_id: when-implementing-adaptive-learning-use-reasoningbank-agentdb name: ReasoningBank Adaptive Learning with AgentDB version: 1.0.0 category: agentdb subcategory: adaptive-learning trigger_pattern: "when-implementing-adaptive-learning" agents: - ml-developer - safla-neural - performance-analyzer complexity: advanced estimated_duration: 8-10 hours prerequisites: - AgentDB advanced features - Reinforcement learning concepts - Neural network understanding outputs: - Reasonin
Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration. Coordinates repo-architect, code-analyzer, and coordinator agents across multiple repositories to maintain consistency, propagate changes, manage dependencies, and ensure architectural alignment. Handles monorepo-to-multi-repo migrations, cross-repo refactoring, and synchronized releases. Use when managing microservices, multi-package ecosystems, or coordinating changes across related repositories.
Validates that code actually works through sandbox testing, execution verification, and systematic debugging. Use this skill after code generation or modification to ensure functionality is genuine rather than assumed. The skill creates isolated test environments, executes code with realistic inputs, identifies bugs through systematic analysis, and applies best practices to fix issues without breaking existing functionality. This ensures code delivers its intended behavior reliably.
Debug ML training issues and optimize performance including loss divergence, overfitting, and slow convergence
# ML Expert - Machine Learning Implementation Specialist **Version**: 1.0.0 **Type**: Agent-based skill with SDK implementation **Domain**: Machine learning model implementation, training, and optimization ## Description Implement machine learning solutions including model architectures, training pipelines, optimization strategies, and performance improvements. This skill spawns a specialist ML implementation agent with deep expertise in PyTorch, deep learning architectures, training techniqu
Configure Claude Code sandbox network isolation with trusted domains, custom access policies, and environment variables
Comprehensive performance profiling, bottleneck detection, and optimization system
# Flow Nexus Neural Network Training SOP ```yaml metadata: skill_name: when-training-neural-networks-use-flow-nexus-neural version: 1.0.0 category: platform-integration difficulty: advanced estimated_duration: 45-90 minutes trigger_patterns: - "train neural network" - "machine learning model" - "distributed training" - "flow nexus neural" - "E2B sandbox training" dependencies: - flow-nexus MCP server - E2B account (optional for cloud) - Claude Flow
Lightning-fast quality check using parallel command execution. Runs theater detection, linting, security scan, and basic tests in parallel for instant feedback on code quality.
Enterprise-grade PowerPoint deck generation system using evidence-based prompting techniques, workflow enforcement, and constraint-based design. Use when creating professional presentations (board decks, reports, analyses) requiring consistent visual quality, accessibility compliance, and integration of complex data from multiple sources. Implements html2pptx workflow with spatial layout optimization, validation gates, and multi-chat architecture for 30+ slide decks.
Comprehensive framework for analyzing, creating, and refining prompts for AI systems. Use when creating prompts for Claude, ChatGPT, or other language models, improving existing prompts, or applying evidence-based prompt engineering techniques. Applies structural optimization, self-consistency patterns, and anti-pattern detection to transform prompts into highly effective versions.
Comprehensive security auditing across static analysis, dynamic testing, dependency vulnerabilities, secrets detection, and OWASP compliance
Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management. Coordinates release-manager, cicd-engineer, tester, and docs-writer agents through hierarchical topology to handle semantic versioning, changelog generation, release notes, deployment validation, and post-release monitoring. Supports multiple release strategies (rolling, blue-green, canary) and automated rollback. Use when creating releases, managing deployments, or coordinating version updates.
--- skill_id: when-implementing-persistent-memory-use-agentdb-memory name: AgentDB Persistent Memory Patterns version: 1.0.0 category: agentdb subcategory: memory-management trigger_pattern: "when-implementing-persistent-memory" agents: - memory-coordinator - swarm-memory-manager - backend-dev complexity: intermediate estimated_duration: 6-8 hours prerequisites: - AgentDB basics - Memory management concepts - Database schema design outputs: - Persistent memory architecture - Sess
Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management. Coordinates cicd-engineer, workflow-automation, tester, and security-auditor agents through mesh topology to create, optimize, and maintain GitHub Actions workflows. Handles workflow generation, performance optimization, security hardening, matrix testing strategies, and workflow debugging. Use when building CI/CD pipelines, optimizing existing workflows, or establishing automation standards.
Comprehensive dependency mapping, analysis, and visualization tool for software projects
Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration
Comprehensive quality verification and validation through static analysis, dynamic testing, integration validation, and certification gates
--- skill_id: when-optimizing-vector-search-use-agentdb-optimization name: AgentDB Vector Search Optimization version: 1.0.0 category: agentdb subcategory: performance-optimization trigger_pattern: "when-optimizing-vector-search" agents: - performance-analyzer - ml-developer - backend-dev complexity: intermediate estimated_duration: 5-7 hours prerequisites: - AgentDB basics - Vector search concepts - Performance profiling skills outputs: - Optimized vector database - 4-32x memory
Proactive token budget management tool for assessing usage, analyzing task complexity, generating chunking strategies, and creating execution plans that stay within budget limits
Complete product launch workflow coordinating 15+ specialist agents across research, development, marketing, sales, and operations. Uses sequential and parallel orchestration for 10-week launch timeline.