claude-flow 2.7.0-alpha.9 → 2.7.1

package/docs/skills/skills-tutorial.md

@@ -0,0 +1,2910 @@
+# 🎓 Claude Code Skills Capabilities Guide
+
+**Version**: 2.0.0
+**Last Updated**: October 19, 2025
+
+> **21 built-in skills + unlimited custom skills.** Discover what each skill does, when to use it, and how to combine skills for complex workflows.
+
+---
+
+## 📖 Table of Contents
+
+1. [What Are Skills?](#-what-are-skills)
+2. [Quick Start](#-quick-start)
+3. [Built-In Skills Catalog](#-built-in-skills-catalog-21-total)
+   - [AI & Memory](#-ai--memory-3-skills)
+   - [GitHub Integration](#-github-integration-5-skills)
+   - [Swarm Orchestration](#-swarm-orchestration-4-skills)
+   - [Development & Quality](#-development--quality-3-skills)
+   - [Cloud Platform](#-cloud-platform-3-skills)
+   - [Automation & Tools](#-automation--tools-2-skills)
+   - [Performance](#-performance-1-skill)
+4. [Skills in Action](#-skills-in-action)
+5. [Combining Skills](#-combining-skills-for-complex-workflows)
+6. [Creating Custom Skills](#-creating-custom-skills)
+7. [Skill Selection Guide](#-skill-selection-guide)
+8. [Best Practices](#-best-practices)
+
+---
+
+## 🌟 What Are Skills?
+
+Skills are **modular capabilities** that Claude Code discovers and uses automatically. Think of them as expert knowledge modules that Claude activates when needed.
+
+**How it works:**
+1. **You ask Claude** to do something ("Implement semantic search")
+2. **Claude finds relevant skills** (agentdb-vector-search)
+3. **Claude loads skill instructions** (how to implement it)
+4. **Claude executes** using the skill's expertise
+5. **Claude learns** and gets faster next time (46% improvement)
+
+**Two types of skills available:**
+- ✅ **21 Built-In Skills** (automatic via claude-flow MCP)
+- ✅ **Custom Skills** (create your own with agentic-flow)
+
+A skill is simply a directory with a `SKILL.md` file containing instructions:
+
+### Skill Structure
+
+```yaml
+---
+name: "AgentDB Vector Search"
+description: "Implement semantic search with 150x-12,500x performance.
+Use for RAG systems, documentation search, similarity matching."
+---
+
+# Instructions
+[Detailed step-by-step guidance...]
+
+# Examples
+[Code examples and use cases...]
+
+# Best Practices
+[What works well, what to avoid...]
+```
+
+**Key features:**
+- 📝 **YAML frontmatter**: Name and description (max 1024 chars)
+- 🎯 **Progressive disclosure**: Claude only loads when relevant
+- 🧠 **Context persistence**: Learns from usage (46% faster over time)
+- 🔄 **Composable**: Skills work together for complex tasks
+
+---
+
+## 🚀 Quick Start
+
+### Installation (30 seconds)
+
+```bash
+# Install claude-flow for 21 built-in skills
+npm install -g claude-flow@alpha
+
+# Add MCP server (makes skills available)
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Verify it's running
+claude mcp list
+# ✓ claude-flow@alpha   npx claude-flow@alpha mcp start   ✓ Running
+
+# That's it! All 21 skills are now available.
+```
+
+### Using Skills (No Setup Required)
+
+Skills activate automatically when relevant:
+
+```
+You: "I need semantic search for my documentation"
+
+Claude: I'll use the agentdb-vector-search skill to implement this.
+[Automatically loads skill instructions and implements solution]
+```
+
+### Creating Custom Skills (Optional)
+
+```bash
+# Install agentic-flow for custom skill creation
+npm install -g agentic-flow@latest
+
+# Initialize skill directories
+npx agentic-flow skills init
+
+# Create sample skills
+npx agentic-flow skills create
+
+# Install skill builder
+npx agentic-flow skills init-builder
+```
+
+---
+
+## 📚 Built-In Skills Catalog (21 Total)
+
+All 21 skills are **automatically available** with claude-flow MCP server. No setup required - just use them!
+
+### 🧠 AI & Memory (3 skills)
+
+#### 1. **agentdb-memory-patterns**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Session memory across conversations
+- Long-term pattern storage
+- Context management with AgentDB
+- Cross-agent memory sharing
+
+**When to use:**
+- Building chatbots with memory
+- Creating stateful AI assistants
+- Implementing conversation history
+- Pattern recognition tasks
+
+---
+
+#### 2. **agentdb-vector-search**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- 150x-12,500x faster than traditional search
+- Semantic similarity matching
+- Vector embeddings with AgentDB
+- Intelligent document retrieval
+
+**When to use:**
+- RAG (Retrieval Augmented Generation) systems
+- Documentation search
+- Code similarity detection
+- Recommendation engines
+
+---
+
+#### 3. **reasoningbank-intelligence**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Pattern learning from execution
+- Strategy optimization
+- 46% performance improvement over time
+- Meta-cognitive capabilities
+
+**When to use:**
+- Self-improving agents
+- Workflow optimization
+- Pattern-based decision making
+- Continuous improvement systems
+
+---
+
+### ☁️ Flow Nexus Platform (3 skills)
+
+#### 4. **flow-nexus-platform**
+```yaml
+description: "Comprehensive Flow Nexus platform management - authentication,
+sandboxes, app deployment, payments, and challenges."
+```
+
+**Key capabilities:**
+- User authentication and management
+- E2B sandbox deployment
+- Application marketplace
+- Payment and credit systems
+
+---
+
+#### 5. **flow-nexus-neural**
+```yaml
+description: "Train and deploy neural networks in distributed E2B sandboxes
+with Flow Nexus."
+```
+
+**Key capabilities:**
+- Distributed neural network training
+- Cloud-based model deployment
+- WASM acceleration
+- Multi-node coordination
+
+---
+
+#### 6. **flow-nexus-swarm**
+```yaml
+description: "Cloud-based AI swarm deployment and event-driven workflow
+automation with Flow Nexus platform."
+```
+
+**Key capabilities:**
+- Cloud swarm deployment
+- Event-driven workflows
+- Message queue processing
+- Scalable agent coordination
+
+---
+
+### 🐙 GitHub Integration (5 skills)
+
+**When to use GitHub skills:**
+- Automated code reviews
+- Multi-repo synchronization
+- Release management
+- CI/CD pipeline creation
+- Project board automation
+
+#### 7. **github-code-review**
+```yaml
+description: "Comprehensive GitHub code review with AI-powered swarm coordination."
+```
+
+**Key capabilities:**
+- Multi-agent code analysis
+- Security vulnerability detection
+- Performance bottleneck identification
+- Automated PR reviews
+
+---
+
+#### 8. **github-multi-repo**
+```yaml
+description: "Multi-repository coordination, synchronization, and architecture
+management with AI swarm orchestration."
+```
+
+**Key capabilities:**
+- Cross-repo synchronization
+- Version alignment
+- Dependency management
+- Organization-wide automation
+
+---
+
+#### 9. **github-project-management**
+```yaml
+description: "Comprehensive GitHub project management with swarm-coordinated
+issue tracking, project board automation, and sprint planning."
+```
+
+**Key capabilities:**
+- Intelligent issue tracking
+- Project board automation
+- Sprint planning
+- Team coordination
+
+---
+
+#### 10. **github-release-management**
+```yaml
+description: "Comprehensive GitHub release orchestration with AI swarm coordination
+for automated versioning, testing, deployment, and rollback management."
+```
+
+**Key capabilities:**
+- Automated versioning
+- Release orchestration
+- Testing coordination
+- Rollback management
+
+---
+
+#### 11. **github-workflow-automation**
+```yaml
+description: "Advanced GitHub Actions workflow automation with AI swarm coordination,
+intelligent CI/CD pipelines, and comprehensive repository management."
+```
+
+**Key capabilities:**
+- CI/CD pipeline automation
+- Workflow optimization
+- Intelligent build coordination
+- Repository automation
+
+---
+
+### 🤖 Swarm & Orchestration (4 skills)
+
+#### 12. **swarm-orchestration**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Multi-agent coordination
+- Dynamic topology selection
+- Parallel task execution
+- Distributed decision making
+
+**When to use:**
+- Complex multi-step tasks
+- Parallel code generation
+- Distributed code reviews
+- Large-scale refactoring
+
+---
+
+#### 13. **swarm-advanced**
+```yaml
+description: "Advanced swarm orchestration patterns for research, development,
+testing, and complex distributed workflows."
+```
+
+**Key capabilities:**
+- Research swarms
+- Development coordination
+- Testing automation
+- Complex workflow patterns
+
+---
+
+#### 14. **hive-mind-advanced**
+```yaml
+description: "Advanced Hive Mind collective intelligence system for queen-led
+multi-agent coordination with consensus mechanisms and persistent memory."
+```
+
+**Key capabilities:**
+- Queen-led coordination
+- Consensus mechanisms
+- Collective intelligence
+- Hierarchical decision making
+
+---
+
+#### 15. **stream-chain**
+```yaml
+description: "Stream-JSON chaining for multi-agent pipelines, data transformation,
+and sequential workflows."
+```
+
+**Key capabilities:**
+- Pipeline processing
+- Data transformation
+- Sequential workflows
+- Stream processing
+
+---
+
+### 📊 Development & Quality (3 skills)
+
+#### 16. **sparc-methodology**
+```yaml
+description: "SPARC (Specification, Pseudocode, Architecture, Refinement, Completion)
+comprehensive development methodology with multi-agent orchestration."
+```
+
+**Key capabilities:**
+- Systematic development phases
+- Specification-driven design
+- Test-driven development
+- Multi-agent coordination
+
+**When to use:**
+- Complex feature development
+- Architecture design
+- Systematic refactoring
+- Team development workflows
+
+---
+
+#### 17. **pair-programming**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Driver/Navigator modes
+- Real-time verification
+- TDD workflows
+- Quality monitoring
+
+---
+
+#### 18. **verification-quality**
+```yaml
+description: "Comprehensive truth scoring, code quality verification, and automatic
+rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs
+and codebase reliability."
+```
+
+**Key capabilities:**
+- Truth scoring
+- Quality verification
+- Automatic rollback
+- Reliability assurance
+
+---
+
+### 🔧 Automation & Tools (2 skills)
+
+#### 19. **hooks-automation**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Pre/post task automation
+- Session management
+- Git integration
+- Neural pattern training
+
+---
+
+#### 20. **skill-builder**
+```yaml
+description: "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."
+```
+
+**Key capabilities:**
+- Interactive skill generation
+- YAML validation
+- Template system
+- Best practices
+
+---
+
+### ⚡ Performance & Analysis (1 skill)
+
+#### 21. **performance-analysis**
+```yaml
+description: "Comprehensive performance analysis, bottleneck detection, and
+optimization recommendations for Claude Flow swarms."
+```
+
+**Key capabilities:**
+- Bottleneck detection
+- Performance profiling
+- Optimization recommendations
+- Metrics collection
+
+---
+
+---
+
+## 🎬 Skills in Action
+
+### Single Skill Examples
+
+#### Example 1: Semantic Search (agentdb-vector-search)
+
+```
+You: "Add semantic search to our documentation site"
+
+Claude (using agentdb-vector-search skill):
+├─ Analyzes your documentation structure
+├─ Sets up AgentDB vector database
+├─ Generates embeddings for all docs
+├─ Implements search API endpoint
+├─ Creates search UI component
+└─ Adds relevance scoring
+
+Result: Working semantic search in minutes
+Performance: 150x faster than traditional search
+Learning: Pattern stored for 46% faster next time
+```
+
+---
+
+#### Example 2: Code Review (github-code-review)
+
+```
+You: "Review PR #123 for security and performance"
+
+Claude (using github-code-review skill):
+├─ Spawns security auditor agent
+├─ Spawns performance analyzer agent
+├─ Spawns code quality reviewer agent
+├─ Coordinates findings via shared memory
+└─ Generates unified review report
+
+Result: Comprehensive multi-angle review
+Agents: 3 specialized reviewers in parallel
+Time: 3.2 seconds for 2,847 files
+```
+
+---
+
+#### Example 3: SPARC Development (sparc-methodology)
+
+```
+You: "Build user authentication system"
+
+Claude (using sparc-methodology skill):
+├─ Specification: Requirements analysis
+├─ Pseudocode: Algorithm design
+├─ Architecture: System design
+├─ Refinement: TDD implementation
+└─ Completion: Integration & testing
+
+Result: Complete auth system with tests
+Process: Systematic, test-driven approach
+Quality: 90%+ code coverage
+```
+
+---
+
+### Combined Skills Workflows
+
+#### Workflow 1: Full-Stack Development
+
+```
+Task: "Build REST API with tests and deploy to GitHub"
+
+Skills activated:
+┌─────────────────────────────────────────┐
+│ 1. sparc-methodology                     │
+│    Plans development phases              │
+├─────────────────────────────────────────┤
+│ 2. swarm-orchestration                   │
+│    Spawns parallel agents:               │
+│    ├─ backend-dev (API)                  │
+│    ├─ tester (tests)                     │
+│    └─ reviewer (quality)                 │
+├─────────────────────────────────────────┤
+│ 3. agentdb-memory-patterns               │
+│    Coordinates agents via shared memory  │
+├─────────────────────────────────────────┤
+│ 4. github-workflow-automation            │
+│    Creates CI/CD pipeline                │
+├─────────────────────────────────────────┤
+│ 5. verification-quality                  │
+│    Validates output (0.95 threshold)     │
+├─────────────────────────────────────────┤
+│ 6. reasoningbank-intelligence            │
+│    Stores patterns for next time         │
+└─────────────────────────────────────────┘
+
+Result: Production-ready API + CI/CD
+Time: Minutes instead of hours
+Learning: 46% faster on next similar project
+```
+
+---
+
+#### Workflow 2: Multi-Repo Release
+
+```
+Task: "Coordinate release across 5 microservices"
+
+Skills activated:
+┌─────────────────────────────────────────┐
+│ 1. github-multi-repo                     │
+│    Syncs versions across repos           │
+├─────────────────────────────────────────┤
+│ 2. github-release-management             │
+│    Orchestrates release process          │
+├─────────────────────────────────────────┤
+│ 3. swarm-orchestration                   │
+│    Parallel testing across services      │
+├─────────────────────────────────────────┤
+│ 4. verification-quality                  │
+│    Validates each service                │
+└─────────────────────────────────────────┘
+
+Result: Coordinated multi-repo release
+Services: 5 microservices in sync
+Safety: Rollback on any failure
+```
+
+---
+
+#### Workflow 3: Performance Optimization
+
+```
+Task: "Optimize slow React application"
+
+Skills activated:
+┌─────────────────────────────────────────┐
+│ 1. performance-analysis                  │
+│    Identifies bottlenecks                │
+├─────────────────────────────────────────┤
+│ 2. agentdb-vector-search                 │
+│    Finds similar optimization patterns   │
+├─────────────────────────────────────────┤
+│ 3. reasoningbank-intelligence            │
+│    Applies learned optimizations         │
+├─────────────────────────────────────────┤
+│ 4. pair-programming                      │
+│    Guides implementation step-by-step    │
+└─────────────────────────────────────────┘
+
+Result: 4x performance improvement
+Approach: Data-driven + pattern-based
+Validation: Before/after metrics
+```
+
+---
+
+## 🔗 Combining Skills for Complex Workflows
+
+### How the Systems Work Together
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Claude Code (User)                       │
+└────────────────┬───────────────────────┬────────────────────┘
+                 │                       │
+    ┌────────────▼─────────┐   ┌────────▼──────────┐
+    │  claude-flow Skills  │   │ agentic-flow Skills│
+    │  (21 Built-In)       │   │  (Custom Created)  │
+    └────────────┬─────────┘   └────────┬──────────┘
+                 │                       │
+                 │    ┌──────────────────┘
+                 │    │
+    ┌────────────▼────▼──────────────────────────────┐
+    │         MCP Integration Layer                  │
+    │  • claude-flow: 213+ coordination tools        │
+    │  • ruv-swarm: Enhanced coordination            │
+    │  • flow-nexus: Cloud capabilities              │
+    │  • agentic-flow: Multi-provider agent runtime  │
+    └────────────┬───────────────────────────────────┘
+                 │
+    ┌────────────▼───────────────────────────────────┐
+    │        Execution & Memory Layer                │
+    │  • AgentDB: Vector search + memory             │
+    │  • ReasoningBank: Pattern learning             │
+    │  • 54 Specialized Agents                       │
+    │  • SPARC Methodology                           │
+    └────────────────────────────────────────────────┘
+```
+
+### Skill Discovery Process
+
+**When Claude Code starts:**
+
+1. **Personal Skills** (`~/.claude/skills/`)
+   - Loads custom skills you've created
+   - Available across all projects
+
+2. **Project Skills** (`.claude/skills/`)
+   - Loads team-shared skills
+   - Version-controlled with git
+
+3. **Built-In Skills** (from claude-flow MCP)
+   - 21 pre-configured skills
+   - Automatically loaded via MCP
+
+4. **Skill Activation**
+   - Claude matches task description to skill descriptions
+   - Loads full skill content when matched
+   - Can use multiple skills simultaneously
+
+### Example: Full Integration
+
+```
+User Request: "Build a REST API with comprehensive tests and deploy to GitHub"
+
+Claude Code coordinates:
+┌─────────────────────────────────────────────────────────────┐
+│ 1. sparc-methodology skill                                   │
+│    └─> Plans systematic development phases                  │
+├─────────────────────────────────────────────────────────────┤
+│ 2. swarm-orchestration skill                                │
+│    ├─> Spawns backend-dev agent (API implementation)        │
+│    ├─> Spawns tester agent (test creation)                  │
+│    └─> Spawns reviewer agent (code review)                  │
+├─────────────────────────────────────────────────────────────┤
+│ 3. agentdb-memory-patterns skill                            │
+│    └─> Coordinates agents via shared memory                 │
+├─────────────────────────────────────────────────────────────┤
+│ 4. github-workflow-automation skill                         │
+│    └─> Creates CI/CD pipeline                               │
+├─────────────────────────────────────────────────────────────┤
+│ 5. verification-quality skill                               │
+│    └─> Validates output quality (0.95 threshold)            │
+├─────────────────────────────────────────────────────────────┤
+│ 6. reasoningbank-intelligence skill                         │
+│    └─> Stores successful patterns for future use            │
+└─────────────────────────────────────────────────────────────┘
+
+MCP Tools Used:
+- mcp__claude-flow__swarm_init (topology setup)
+- mcp__claude-flow__agent_spawn (create agents)
+- mcp__claude-flow__memory_usage (coordination)
+- mcp__claude-flow__github_workflow_auto (CI/CD)
+
+Result: Complete REST API with tests, deployed to GitHub,
+        patterns stored for 46% faster next execution
+```
+
+---
+
+## 💡 Benefits
+
+### 1. **Context Persistence** 🧠
+Unlike prompts that reset every session, Skills maintain context through AgentDB:
+```javascript
+// Traditional: Context lost every time
+"Please analyze this API design"  // Forgets previous analyses
+
+// With Skills: Context accumulates
+AgentDB stores: [previous API patterns, success metrics, failure cases]
+Skill applies: Learned best practices from 100+ prior analyses
+```
+
+### 2. **Adaptive Intelligence** 🎯
+Skills learn and improve through feedback loops:
+- **First run**: 70% success rate, generic approach
+- **After 10 runs**: 90% success rate, optimized patterns
+- **After 100 runs**: Domain expertise encoded in memory graph
+
+### 3. **Modular Reusability** 🔧
+Build once, use everywhere:
+```bash
+# Personal project
+~/.claude/skills/api-design/
+
+# Team repository
+.claude/skills/api-design/
+
+# Organization-wide
+Shared across all Claude Code instances
+```
+
+### 4. **Multi-Agent Coordination** 🤝
+Skills orchestrate complex workflows automatically:
+```
+Swarm Orchestration Skill:
+  1. Spawn coder agent (write implementation)
+  2. Spawn tester agent (write tests)
+  3. Spawn reviewer agent (code review)
+  4. Coordinate via shared AgentDB memory
+  5. Synthesize final output
+```
+
+### 5. **Traceable Reasoning** 📊
+Every decision leaves an audit trail:
+- What skill was activated?
+- What reasoning pattern was applied?
+- What memory was retrieved from AgentDB?
+- What was the confidence score?
+- What feedback was recorded?
+
+### 6. **Zero Configuration** ⚡
+Skills auto-discover and self-organize:
+```bash
+# Create skill directory
+npx agentic-flow skills init
+
+# Create example skills
+npx agentic-flow skills create
+
+# That's it! Claude Code finds them automatically
+```
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+```bash
+# Verify Node.js installation
+node --version    # v18.0.0 or higher
+npm --version     # v9.0.0 or higher
+
+# Option 1: Install claude-flow (includes 21 built-in skills + 213+ MCP tools)
+npm install -g claude-flow@alpha
+npx claude-flow --version  # Should show 2.7.0 or higher
+
+# Option 2: Install agentic-flow (for custom skill creation)
+npm install -g agentic-flow@latest
+npx agentic-flow --version  # Should show 1.7.3 or higher
+
+# Recommended: Install both for full capabilities
+npm install -g claude-flow@alpha agentic-flow@latest
+```
+
+### Setup MCP Servers
+
+```bash
+# Add claude-flow MCP server (required for 21 built-in skills)
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Optional: Add additional MCP servers for enhanced capabilities
+claude mcp add ruv-swarm npx ruv-swarm mcp start              # Enhanced coordination
+claude mcp add flow-nexus npx flow-nexus@latest mcp start    # Cloud features
+claude mcp add agentic-flow npx agentic-flow@latest mcp start  # Multi-provider agents
+
+# Verify MCP servers are running
+claude mcp list
+
+# Should show:
+# claude-flow@alpha   npx claude-flow@alpha mcp start   ✓ Running
+```
+
+### Step 1: Initialize Skills Directories
+
+```bash
+# Initialize both personal and project skills
+npx agentic-flow skills init
+```
+
+**What this does:**
+- ✅ Creates `~/.claude/skills/` (personal, global)
+- ✅ Creates `.claude/skills/` (project, version-controlled)
+
+**Output:**
+```
+🎨 Initializing agentic-flow Skills
+═══════════════════════════════════════════════════════════════
+
+✓ Created personal skills directory: /home/user/.claude/skills
+✓ Created project skills directory: /workspace/.claude/skills
+
+✓ Skills directories initialized!
+```
+
+> 💡 **Pro Tip**: Personal skills are available across ALL projects. Project skills are team-shared via git.
+
+---
+
+### Step 2: Create Example Skills
+
+```bash
+# Create 4 built-in agentic-flow skills
+npx agentic-flow skills create
+```
+
+**What you get:**
+```
+✓ Created 4 agentic-flow skills!
+
+Skills installed:
+  • AgentDB Vector Search    - Semantic search with vector embeddings
+  • AgentDB Memory Patterns  - Memory management & persistence
+  • Swarm Orchestration      - Multi-agent coordination
+  • ReasoningBank Intelligence - Pattern learning & adaptation
+```
+
+**File structure:**
+```
+.claude/skills/
+  ├── agentdb-vector-search/
+  │   └── SKILL.md
+  ├── agentdb-memory-patterns/
+  │   └── SKILL.md
+  ├── swarm-orchestration/
+  │   └── SKILL.md
+  └── reasoningbank-intelligence/
+      └── SKILL.md
+```
+
+---
+
+### Step 3: Install Skill Builder Framework
+
+```bash
+# Install the comprehensive skill creation framework
+npx agentic-flow skills init-builder
+```
+
+**What this provides:**
+- ✅ **Interactive skill generator** - Build skills through guided prompts
+- ✅ **3 skill templates** - Minimal, full-featured, and advanced patterns
+- ✅ **YAML validation** - Automatic frontmatter verification
+- ✅ **Generation scripts** - Automated skill scaffolding
+- ✅ **Best practices guide** - Industry-standard patterns
+- ✅ **Example skills** - Real-world implementations
+
+**File structure:**
+```
+.claude/skills/skill-builder/
+  ├── SKILL.md                    # Main skill-builder skill
+  ├── README.md                   # Quick reference guide
+  ├── docs/
+  │   ├── SPECIFICATION.md        # Complete Claude Skills spec
+  │   ├── EXAMPLES.md             # Real-world examples
+  │   └── BEST_PRACTICES.md       # Design patterns
+  ├── scripts/
+  │   ├── generate-skill.sh       # Interactive skill generator
+  │   ├── validate-skill.sh       # YAML/structure validator
+  │   ├── test-skill.sh           # Skill testing utility
+  │   └── publish-skill.sh        # Team sharing helper
+  ├── resources/
+  │   ├── templates/              # Pre-built skill templates
+  │   │   ├── minimal.md          # Basic skill structure
+  │   │   ├── full-featured.md    # Complete with all sections
+  │   │   └── advanced.md         # Multi-agent coordination
+  │   └── schemas/
+  │       ├── skill-schema.json   # JSON schema for validation
+  │       └── frontmatter.yaml    # YAML frontmatter spec
+  └── templates/                  # Working example skills
+      ├── api-design-pattern.md
+      ├── testing-framework.md
+      └── documentation-generator.md
+```
+
+**Why use skill-builder?**
+- 🚀 **10x faster** than manual skill creation
+- ✅ **Guaranteed valid** YAML frontmatter
+- 📝 **Best practices** automatically applied
+- 🎨 **Customizable** templates for your domain
+- 🔧 **Team-ready** sharing and validation tools
+
+---
+
+### Step 4: List All Available Skills
+
+```bash
+# See all installed skills
+npx agentic-flow skills list
+```
+
+**Output:**
+```
+📚 Installed Claude Code Skills
+═══════════════════════════════════════════════════════════════
+
+Personal Skills (~/.claude/skills/)
+  • Skill Builder
+     Create new Claude Code Skills with proper YAML frontmatter...
+
+Project Skills (.claude/skills/)
+  • AgentDB Memory Patterns
+     Implement persistent memory patterns for AI agents...
+  • AgentDB Vector Search
+     Implement semantic vector search with AgentDB...
+  • Swarm Orchestration
+     Orchestrate multi-agent swarms with agentic-flow...
+  • ReasoningBank Intelligence
+     Implement adaptive learning with ReasoningBank...
+```
+
+---
+
+## 📚 Understanding the 4 Built-In Sample Skills
+
+When you run `npx agentic-flow skills create`, you get 4 production-ready skills:
+
+### 1. AgentDB Vector Search
+
+**What it does:** Semantic search with 150x-12,500x performance improvement
+
+**When to use:**
+- Building RAG (Retrieval Augmented Generation) systems
+- Implementing intelligent search in documentation
+- Creating recommendation engines
+- Finding similar code/content
+
+**Key capabilities:**
+```javascript
+// Vector embeddings with AgentDB
+await db.vectorDB.insert(embedding, {
+  id: 'doc-123',
+  content: 'React hooks tutorial',
+  tags: ['react', 'hooks']
+});
+
+// Semantic search (finds similar meaning, not just keywords)
+const results = await db.vectorDB.search(queryEmbedding, {
+  k: 10,  // Top 10 results
+  threshold: 0.7  // 70% similarity minimum
+});
+```
+
+**Example use cases:**
+- Documentation search (search by meaning)
+- Code similarity detection
+- Intelligent autocomplete
+- Content recommendations
+
+---
+
+### 2. AgentDB Memory Patterns
+
+**What it does:** Persistent memory management across sessions
+
+**When to use:**
+- Building stateful agents that remember context
+- Creating chat systems with conversation history
+- Implementing pattern learning
+- Storing user preferences
+
+**Key capabilities:**
+```javascript
+// Session memory - persists across conversations
+await reasoningbank.storeMemory('user_preference', 'dark mode', {
+  namespace: 'settings',
+  sessionId: 'user-123'
+});
+
+// Cross-session retrieval
+const prefs = await reasoningbank.queryMemories('user preferences', {
+  namespace: 'settings',
+  sessionId: 'user-123'
+});
+
+// Pattern learning - remember what works
+await reasoningbank.storePattern({
+  pattern: 'api-pagination',
+  approach: 'cursor-based',
+  success: true,
+  confidence: 0.95
+});
+```
+
+**Example use cases:**
+- Chat history management
+- User preference storage
+- Pattern recognition
+- Context persistence
+
+---
+
+### 3. Swarm Orchestration
+
+**What it does:** Multi-agent coordination with intelligent task distribution
+
+**When to use:**
+- Complex tasks requiring multiple specialized agents
+- Parallel code generation (frontend + backend + tests)
+- Comprehensive code reviews
+- Large-scale refactoring
+
+**Key capabilities:**
+```javascript
+// Initialize coordinated swarm
+const swarm = await initializeSwarm({
+  topology: 'mesh',  // Agents communicate peer-to-peer
+  agents: [
+    { type: 'coder', focus: 'implementation' },
+    { type: 'tester', focus: 'test coverage' },
+    { type: 'reviewer', focus: 'code quality' }
+  ],
+  coordination: 'agentdb'  // Shared memory
+});
+
+// Agents work in parallel, share context via AgentDB
+for (const agent of swarm.agents) {
+  await agent.execute();  // Parallel execution
+  await agentDB.store(agent.results);  // Share findings
+}
+
+// Synthesize collective intelligence
+const synthesis = await agentDB.synthesize({
+  namespace: 'code-review',
+  strategy: 'consensus'
+});
+```
+
+**Example use cases:**
+- Multi-agent code generation
+- Distributed code review
+- Parallel testing workflows
+- Complex refactoring
+
+---
+
+### 4. ReasoningBank Intelligence
+
+**What it does:** Adaptive learning with 46% performance improvement
+
+**When to use:**
+- Tasks you repeat frequently (API design, testing patterns)
+- Workflows that benefit from learning
+- Domain-specific knowledge accumulation
+- Performance optimization
+
+**Key capabilities:**
+```javascript
+// Store successful patterns
+await reasoningbank.storePattern({
+  domain: 'api-design',
+  pattern: 'authentication',
+  approach: 'JWT with refresh tokens',
+  metrics: {
+    security: 'excellent',
+    performance: 'optimized',
+    maintainability: 'high'
+  },
+  success: true
+});
+
+// Query learned patterns
+const bestApproach = await reasoningbank.queryPatterns('authentication', {
+  domain: 'api-design',
+  sortBy: 'success_rate'
+});
+
+// Continuous improvement - learns from each execution
+// First time: generic approach
+// After 10 runs: optimized with learned patterns
+// After 100 runs: domain expertise
+```
+
+**Example use cases:**
+- API design patterns
+- Testing strategies
+- Code architecture decisions
+- Performance optimization
+
+---
+
+## 🎨 Using Skills with Claude Code
+
+### Concept: Autonomous Skill Discovery
+
+**Claude Code automatically discovers and uses skills** when they're relevant to your task. You don't need to explicitly invoke them. Claude decides when to apply which skill based on context.
+
+### Workflow 1: Semantic Search Implementation
+
+**Scenario**: You need to implement semantic search for a documentation site.
+
+#### Step 1: Ask Claude Code
+
+Open Claude Code and type:
+```
+I need to implement semantic search for our documentation.
+The docs are in markdown files and I want users to search by meaning, not keywords.
+```
+
+#### Step 2: Claude Discovers the Skill
+
+Claude Code automatically:
+1. ✅ Scans `.claude/skills/`
+2. ✅ Finds `agentdb-vector-search/SKILL.md`
+3. ✅ Recognizes "semantic search" matches skill description
+4. ✅ Loads skill instructions
+
+#### Step 3: Claude Applies the Skill
+
+Claude responds with:
+```
+I'll help you implement semantic search using AgentDB's vector search capabilities.
+I found the AgentDB Vector Search skill which provides a 150x-12,500x performance
+improvement over traditional search.
+
+Here's my implementation plan:
+[Detailed plan based on skill instructions...]
+```
+
+#### Step 4: Skill Execution
+
+Claude follows the skill's reasoning pattern:
+```javascript
+// 1. Initialize AgentDB with vector support
+import { AgentDB } from 'agentdb';
+
+const db = new AgentDB({
+  mode: 'node',
+  vectorDimensions: 384,  // From skill template
+  enableOptimizations: true
+});
+
+// 2. Create vector index (from skill instructions)
+await db.vectorDB.createIndex({
+  dimension: 384,
+  metric: 'cosine'
+});
+
+// 3. Index documents with embeddings
+const docs = await loadMarkdownFiles('./docs/**/*.md');
+for (const doc of docs) {
+  const embedding = await generateEmbedding(doc.content);
+  await db.vectorDB.insert(embedding, {
+    id: doc.id,
+    title: doc.title,
+    content: doc.content,
+    url: doc.url
+  });
+}
+
+// 4. Implement search function
+async function searchDocs(query) {
+  const queryEmbedding = await generateEmbedding(query);
+  const results = await db.vectorDB.search(queryEmbedding, {
+    k: 10,
+    includeMetadata: true
+  });
+  return results;
+}
+```
+
+#### Step 5: Learning Loop
+
+After successful execution:
+```javascript
+// AgentDB stores the pattern
+await db.storePattern({
+  skill: 'agentdb-vector-search',
+  task: 'documentation search',
+  approach: 'markdown indexing with 384-dim embeddings',
+  performance: { searchTime: '2ms', accuracy: '95%' },
+  success: true
+});
+```
+
+**Next time**: Claude remembers this approach and applies it 46% faster.
+
+---
+
+### Workflow 2: Multi-Agent Code Review
+
+**Scenario**: You want to review a large codebase with multiple specialized agents.
+
+#### Step 1: Ask Claude Code
+
+```
+I need a comprehensive code review of our TypeScript backend.
+Check for bugs, security issues, performance problems, and best practices.
+```
+
+#### Step 2: Claude Discovers Swarm Orchestration Skill
+
+Claude Code:
+1. ✅ Recognizes "comprehensive review" needs multiple specialized agents
+2. ✅ Loads `swarm-orchestration/SKILL.md`
+3. ✅ Plans multi-agent coordination
+
+#### Step 3: Skill Orchestrates Agents
+
+```
+I'll coordinate a swarm of specialized review agents:
+
+Spawning agents:
+  1. Security Auditor - Scanning for vulnerabilities
+  2. Performance Analyzer - Identifying bottlenecks
+  3. Code Quality Reviewer - Checking best practices
+  4. Type Safety Checker - Verifying TypeScript types
+
+Coordination mode: Mesh topology with shared AgentDB memory
+```
+
+#### Step 4: Agents Execute in Parallel
+
+```javascript
+// Behind the scenes (from swarm-orchestration skill)
+const swarm = await initializeSwarm({
+  topology: 'mesh',
+  agents: [
+    { type: 'security', focus: 'OWASP Top 10' },
+    { type: 'performance', focus: 'Big O analysis' },
+    { type: 'quality', focus: 'SOLID principles' },
+    { type: 'types', focus: 'TypeScript strictness' }
+  ],
+  coordination: 'agentdb'  // Shared memory via AgentDB
+});
+
+// Each agent stores findings in shared memory
+for (const agent of swarm.agents) {
+  await agent.execute();
+  await agentDB.store(agent.findings, {
+    namespace: 'code-review',
+    agentId: agent.id
+  });
+}
+
+// Synthesize final report
+const allFindings = await agentDB.query({
+  namespace: 'code-review',
+  similarity: 'cluster'  // Group related issues
+});
+```
+
+#### Step 5: Synthesized Results
+
+Claude presents unified findings:
+```
+Code Review Complete (4 agents, 2,847 files analyzed in 3.2 seconds)
+
+🔴 Critical (3):
+  - SQL injection vulnerability in auth.ts:42
+  - Unvalidated user input in api/users.ts:156
+  - Memory leak in websocket handler
+
+🟡 Warnings (12):
+  - N+1 query pattern in database/posts.ts
+  - Missing error boundaries in React components
+  [...]
+
+✅ Best Practices (8 suggestions):
+  - Consider using dependency injection
+  - Add JSDoc comments for public APIs
+  [...]
+
+Performance Analysis:
+  - Average response time: 45ms → could be 12ms with caching
+  - Database queries: 234 → could be 67 with batching
+```
+
+---
+
+### Workflow 3: Adaptive Learning with ReasoningBank
+
+**Scenario**: You're building a REST API and want Claude to learn your patterns.
+
+#### Step 1: First API Implementation
+
+```
+Create a REST API endpoint for user registration.
+```
+
+Claude (first time, generic approach):
+```javascript
+// Basic implementation (no prior learning)
+app.post('/api/users', async (req, res) => {
+  const user = await User.create(req.body);
+  res.json(user);
+});
+```
+
+**Result**: Works but missing validation, error handling, security.
+
+#### Step 2: Feedback & Learning
+
+```
+This needs better error handling, validation, and security.
+```
+
+Claude improves and stores the pattern:
+```javascript
+// Improved implementation
+app.post('/api/users', [
+  validateRequest(userSchema),    // Added validation
+  sanitizeInput(),                 // Added sanitization
+  async (req, res, next) => {
+    try {
+      const user = await User.create(req.body);
+      res.status(201).json({
+        success: true,
+        data: user
+      });
+    } catch (error) {
+      next(error);  // Proper error handling
+    }
+  }
+]);
+
+// AgentDB stores this pattern via ReasoningBank skill
+await reasoningbank.storePattern({
+  domain: 'rest-api',
+  pattern: 'user-registration',
+  approach: 'validation + sanitization + try-catch',
+  confidence: 0.95
+});
+```
+
+#### Step 3: Second API Implementation (Learning Applied)
+
+```
+Create a REST API endpoint for password reset.
+```
+
+Claude (with learned patterns):
+```javascript
+// Automatically applies learned patterns!
+app.post('/api/auth/reset-password', [
+  validateRequest(passwordResetSchema),  // ✅ Remembered validation
+  sanitizeInput(),                       // ✅ Remembered sanitization
+  rateLimiter({ max: 5, window: '15m' }), // ✅ Added security best practice
+  async (req, res, next) => {
+    try {
+      const token = await generateResetToken(req.body.email);
+      await sendResetEmail(req.body.email, token);
+
+      res.status(200).json({
+        success: true,
+        message: 'Reset email sent'
+      });
+    } catch (error) {
+      next(error);  // ✅ Proper error handling
+    }
+  }
+]);
+```
+
+**Result**: 46% faster implementation, 90%+ best practices compliance, zero manual reminders.
+
+---
+
+## 🤖 Using Skills with Claude Agent SDK & agentic-flow Agents
+
+### Concept: Programmatic Skill Execution
+
+The **Claude Agent SDK** (released October 2025) enables programmatic agent development with Skills support. **agentic-flow** extends the SDK with multi-agent coordination, persistent memory, and vector search.
+
+### Claude Agent SDK Integration
+
+**Official SDK usage with Skills:**
+```typescript
+import { Agent } from '@anthropic-ai/claude-agent-sdk';
+
+// Create agent (auto-discovers skills in ~/.claude/skills/)
+const agent = new Agent({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-5-20250929',
+  skillsDir: './.claude/skills'  // Project-specific skills
+});
+
+// Agent automatically uses relevant skills
+const result = await agent.run({
+  task: 'Implement semantic search for our documentation'
+});
+
+// Skills are loaded automatically based on task description matching
+```
+
+### agentic-flow Enhancement of Claude Agent SDK
+
+**agentic-flow adds enterprise capabilities:**
+
+```javascript
+import * as agenticFlow from 'agentic-flow';
+import { AgentDB } from 'agentdb';
+
+// Initialize with AgentDB memory backend
+const db = new AgentDB({
+  mode: 'node',
+  vectorDimensions: 384,
+  enableOptimizations: true
+});
+
+// Initialize ReasoningBank with AgentDB
+await agenticFlow.reasoningbank.initialize({
+  backend: 'agentdb',
+  db
+});
+
+// Run agent with persistent learning
+const agent = await agenticFlow.createAgent({
+  type: 'coder',
+  model: 'claude-sonnet-4-5-20250929',
+  skillsDir: './.claude/skills',
+  memory: db,  // Persistent memory across sessions
+  learning: true  // Enable ReasoningBank pattern learning
+});
+
+// Execute task - skills auto-discovered + patterns learned
+const result = await agent.execute({
+  task: 'Implement semantic search for our documentation'
+});
+
+// Pattern automatically stored in AgentDB for future use
+// Next time: 46% faster with learned patterns
+```
+
+### Multi-Agent Coordination with Skills
+
+**agentic-flow swarm orchestration:**
+
+```javascript
+import * as agenticFlow from 'agentic-flow';
+
+// Initialize swarm with shared AgentDB memory
+const swarm = await agenticFlow.swarm.initialize({
+  topology: 'mesh',  // Agents communicate peer-to-peer
+  agents: [
+    {
+      type: 'researcher',
+      skillsDir: './.claude/skills',  // All agents share skills
+      memory: 'shared'  // Shared AgentDB instance
+    },
+    {
+      type: 'coder',
+      skillsDir: './.claude/skills',
+      memory: 'shared'
+    },
+    {
+      type: 'tester',
+      skillsDir: './.claude/skills',
+      memory: 'shared'
+    }
+  ],
+  coordination: {
+    backend: 'agentdb',  // Coordinate via vector memory
+    consensus: 'majority'  // Decision-making strategy
+  }
+});
+
+// Orchestrate task across multiple agents
+// Each agent uses relevant skills + shares learnings via AgentDB
+const result = await swarm.orchestrate({
+  task: 'Build a REST API with comprehensive tests'
+});
+
+// All agents contribute patterns to shared memory
+// Future executions benefit from collective intelligence
+```
+
+### Skills + Claude Agent SDK + agentic-flow Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    User Application                      │
+└────────────────────┬────────────────────────────────────┘
+                     │
+        ┌────────────▼────────────┐
+        │  Claude Agent SDK       │  ← Official Anthropic SDK
+        │  - Agent creation       │
+        │  - Skill discovery      │
+        │  - Task execution       │
+        └────────────┬────────────┘
+                     │
+        ┌────────────▼────────────┐
+        │  agentic-flow Layer     │  ← Enterprise features
+        │  - Multi-agent swarms   │
+        │  - AgentDB integration  │
+        │  - ReasoningBank        │
+        │  - Skill-builder        │
+        └────────────┬────────────┘
+                     │
+     ┌───────────────┼───────────────┐
+     │               │               │
+┌────▼─────┐  ┌─────▼──────┐  ┌────▼──────┐
+│  Skills  │  │  AgentDB   │  │ Reasoning │
+│ (.claude)│  │  (Memory)  │  │   Bank    │
+└──────────┘  └────────────┘  └───────────┘
+```
+
+While Claude Code uses skills automatically, you can also invoke them programmatically via the agentic-flow agent system.
+
+### Agent + Skill Integration
+
+```bash
+# Run an agent with specific skill context
+npx agentic-flow \
+  --agent coder \
+  --task "Implement semantic search" \
+  --skill agentdb-vector-search
+```
+
+**What happens:**
+1. Agent loads with skill's reasoning patterns pre-loaded
+2. Skill provides domain-specific context
+3. Agent applies skill patterns to the task
+4. Results stored in AgentDB for future learning
+
+### Example: Full-Stack Application with Skills
+
+```bash
+# Scenario: Build a complete app with coordinated agents
+npx agentic-flow \
+  --agent swarm \
+  --task "Build a todo app with React + Node + PostgreSQL" \
+  --skill swarm-orchestration
+```
+
+**Behind the scenes:**
+```javascript
+// swarm-orchestration skill coordinates multiple agents
+const swarm = {
+  agents: [
+    { type: 'backend-dev', task: 'Build Node/Express API', skill: 'api-patterns' },
+    { type: 'frontend-dev', task: 'Build React UI', skill: 'react-patterns' },
+    { type: 'database-architect', task: 'Design PostgreSQL schema', skill: 'db-design' },
+    { type: 'tester', task: 'Write Jest tests', skill: 'testing-patterns' },
+    { type: 'reviewer', task: 'Code review', skill: 'quality-checks' }
+  ],
+  coordination: {
+    memory: 'agentdb',      // Shared context
+    topology: 'hierarchical', // Backend → Frontend → Tests
+    feedback: 'continuous'    // Real-time learning
+  }
+};
+
+// Execute with skill-guided reasoning
+for (const agent of swarm.agents) {
+  const skillContext = await loadSkill(agent.skill);
+  const result = await agent.execute({
+    task: agent.task,
+    context: skillContext,
+    sharedMemory: agentDB
+  });
+
+  // Store patterns for future use
+  await reasoningbank.learn(result);
+}
+```
+
+**Output**: Complete app in minutes with learned best practices applied.
+
+---
+
+## 🛠️ Creating Custom Skills
+
+### When to Create a Custom Skill
+
+Create a skill when you have a **repeatable reasoning pattern** that:
+- ✅ You use frequently across projects
+- ✅ Requires domain-specific knowledge
+- ✅ Benefits from learning and adaptation
+- ✅ Needs coordination with other skills/agents
+
+### Method 1: Using Skill Builder (Recommended)
+
+The skill-builder framework provides **3 ways** to create skills:
+
+#### Option A: Interactive Generation with Claude Code
+
+**Step 1: Ask Claude Code to use skill-builder**
+
+```
+Use the skill-builder to create a custom skill for GraphQL API design.
+I want it to cover schema design, resolvers, and performance optimization.
+```
+
+**Step 2: Claude discovers and uses skill-builder skill**
+
+Claude (automatically loads skill-builder skill):
+```
+I'll help you create a GraphQL API Design skill using the skill-builder framework.
+
+Following the skill-builder template...
+✓ Analyzing requirements
+✓ Selecting template: full-featured (comprehensive with examples)
+✓ Generating YAML frontmatter
+✓ Creating progressive disclosure structure
+✓ Adding code examples
+✓ Validating skill structure
+
+Creating: .claude/skills/graphql-api-design/SKILL.md
+```
+
+**Step 3: Claude generates a complete skill**
+
+```yaml
+---
+name: "GraphQL API Design"
+description: "Design GraphQL APIs following best practices for schema design,
+resolvers, and performance. Use when building or refactoring GraphQL services."
+---
+
+# GraphQL API Design
+
+## What This Skill Does
+Guides the design of GraphQL APIs with focus on schema-first development,
+efficient resolvers, and query optimization.
+
+## When to Use
+- Designing new GraphQL schemas
+- Refactoring existing APIs
+- Optimizing query performance
+- Implementing federation
+
+## Prerequisites
+- Node.js 18+
+- GraphQL 16+
+- Apollo Server or similar
+
+## Quick Start
+
+### 1. Schema Design
+\`\`\`graphql
+# Design schema with clear types
+type User {
+  id: ID!
+  email: String!
+  posts: [Post!]!
+}
+
+type Post {
+  id: ID!
+  title: String!
+  content: String!
+  author: User!
+}
+\`\`\`
+
+### 2. Resolver Pattern
+\`\`\`javascript
+const resolvers = {
+  Query: {
+    user: async (_, { id }, { dataSources }) => {
+      return dataSources.userAPI.getUser(id);
+    }
+  },
+  User: {
+    posts: async (user, _, { dataSources }) => {
+      return dataSources.postAPI.getPostsByUserId(user.id);
+    }
+  }
+};
+\`\`\`
+
+### 3. Performance Optimization
+- Use DataLoader for N+1 query prevention
+- Implement query complexity analysis
+- Add caching layers
+- Monitor resolver timing
+
+## Advanced Patterns
+[Detailed federation, subscriptions, etc...]
+
+## Learn More
+- Schema design principles
+- Resolver best practices
+- Performance optimization strategies
+```
+
+#### Step 3: Skill is Auto-Discovered
+
+```bash
+# Verify it's available
+npx agentic-flow skills list
+
+# Output includes:
+# • GraphQL API Design
+#    Design GraphQL APIs following best practices...
+```
+
+---
+
+### Method 2: Manual Creation
+
+#### Step 1: Create Directory
+
+```bash
+mkdir -p .claude/skills/my-custom-skill
+```
+
+#### Step 2: Create SKILL.md
+
+```bash
+cat > .claude/skills/my-custom-skill/SKILL.md << 'EOF'
+---
+name: "My Custom Skill"
+description: "Brief description of what this skill does and when to use it.
+Maximum 1024 characters."
+---
+
+# My Custom Skill
+
+## What This Skill Does
+Explain the skill's purpose clearly.
+
+## When to Use
+- Use case 1
+- Use case 2
+
+## Prerequisites
+- Requirement 1
+- Requirement 2
+
+## Quick Start
+Step-by-step instructions...
+
+EOF
+```
+
+#### Step 3: Validate
+
+```bash
+# Use skill-builder to validate
+npx agentic-flow skills validate .claude/skills/my-custom-skill/SKILL.md
+```
+
+**Output:**
+```
+✓ YAML frontmatter valid
+✓ Name field present (64 char max)
+✓ Description field present (1024 char max)
+✓ Markdown structure valid
+✓ Skill ready to use
+```
+
+---
+
+## 🚀 Advanced Workflows
+
+### Workflow 1: Using Skill Builder to Create Domain-Specific Skills
+
+**Scenario**: Your team builds microservices with Node.js and wants standardized patterns.
+
+#### Step 1: Generate microservice design skill
+
+Ask Claude Code:
+```
+Use skill-builder to create a skill for microservice architecture design.
+Include service boundaries, communication patterns, and observability.
+Base it on our Node.js + Docker + Kubernetes stack.
+```
+
+Claude (using skill-builder):
+```
+Creating "Microservice Architecture Design" skill...
+
+✓ Analyzing domain: microservices, Node.js, K8s
+✓ Loading template: advanced (multi-agent coordination)
+✓ Generating sections:
+  - Service boundary patterns
+  - Communication strategies (sync/async)
+  - Observability stack (logs, metrics, traces)
+  - Deployment patterns
+  - Testing strategies
+✓ Adding tech-specific examples (Node.js, Docker, K8s)
+✓ Validating against Claude Skills specification
+
+Created: .claude/skills/microservice-architecture-design/SKILL.md
+```
+
+#### Step 2: Generate companion testing skill
+
+```
+Use skill-builder to create a microservice testing skill.
+Cover unit, integration, contract, and E2E testing.
+```
+
+Claude generates:
+```
+.claude/skills/microservice-testing-patterns/SKILL.md
+```
+
+#### Step 3: Use both skills together
+
+```
+Design and implement a payment microservice with complete test coverage.
+```
+
+Claude Code:
+1. ✅ Discovers `microservice-architecture-design` skill
+2. ✅ Applies service boundary patterns
+3. ✅ Discovers `microservice-testing-patterns` skill
+4. ✅ Generates comprehensive test suite
+5. ✅ Stores learned patterns in AgentDB for future projects
+
+**Result**: Consistent microservice architecture across your entire team.
+
+---
+
+### Workflow 2: Skill Builder + AgentDB Learning Loop
+
+**Scenario**: Build a skill that gets smarter with each use.
+
+#### Step 1: Create adaptive skill
+
+```
+Use skill-builder to create a React performance optimization skill.
+Make it learn from each optimization and improve recommendations.
+```
+
+Claude generates skill with ReasoningBank integration:
+```yaml
+---
+name: "React Performance Optimization"
+description: "Adaptive React optimization with learning from past improvements.
+Uses ReasoningBank to remember successful patterns."
+---
+
+# React Performance Optimization
+
+## Quick Start
+
+### 1. Profile Current Performance
+\`\`\`javascript
+// ReasoningBank checks: Have we optimized similar components?
+const priorOptimizations = await reasoningbank.queryPatterns('react-perf', {
+  componentType: 'data-table',
+  sortBy: 'impact'
+});
+
+// Apply learned patterns automatically
+if (priorOptimizations.length > 0) {
+  console.log('Applying learned patterns:', priorOptimizations[0].approach);
+}
+\`\`\`
+
+### 2. Apply Optimizations
+[Skill guides through optimizations...]
+
+### 3. Store Results
+\`\`\`javascript
+// After optimization, record results
+await reasoningbank.storePattern({
+  domain: 'react-perf',
+  componentType: 'data-table',
+  approach: 'virtualization + memoization',
+  metrics: {
+    beforeFPS: 15,
+    afterFPS: 60,
+    improvement: '4x'
+  },
+  success: true
+});
+\`\`\`
+```
+
+#### Step 2: Use the skill multiple times
+
+**First use:**
+```
+Optimize this React data table component.
+```
+
+Claude applies generic best practices (no prior learning).
+
+**After 5 uses:**
+Claude now knows:
+- Virtualization works best for >1000 rows
+- useMemo is critical for computed columns
+- React.memo prevents unnecessary rerenders
+
+**After 20 uses:**
+Claude has domain expertise:
+- Automatically suggests optimal patterns
+- Predicts performance impact
+- Applies 95%+ best practices without prompting
+
+---
+
+### Workflow 3: Cross-Skill Composition
+
+Skills can reference and coordinate with each other:
+
+```yaml
+---
+name: "Full-Stack E-Commerce Platform"
+description: "Build complete e-commerce platform coordinating multiple skills."
+---
+
+# Full-Stack E-Commerce Platform
+
+## Skill Dependencies
+This meta-skill orchestrates:
+1. `microservice-architecture-design` - Backend services
+2. `react-performance-optimization` - Frontend performance
+3. `agentdb-vector-search` - Product search
+4. `swarm-orchestration` - Multi-agent coordination
+5. `reasoningbank-intelligence` - Pattern learning
+
+## Execution Flow
+1. **Architecture Phase** (microservice-architecture-design)
+   - Design service boundaries
+   - Define communication patterns
+   - Plan data consistency strategy
+
+2. **Implementation Phase** (swarm-orchestration)
+   - Spawn: Backend team (payment, catalog, user services)
+   - Spawn: Frontend team (React components)
+   - Spawn: Testing team (contract + E2E tests)
+   - Coordinate via AgentDB shared memory
+
+3. **Optimization Phase** (react-performance-optimization, agentdb-vector-search)
+   - Optimize product catalog rendering
+   - Implement semantic product search
+   - Add intelligent recommendations
+
+4. **Learning Phase** (reasoningbank-intelligence)
+   - Store successful patterns
+   - Record performance metrics
+   - Prepare for next e-commerce project
+```
+
+**Using this meta-skill:**
+```
+Build an e-commerce platform for selling digital products.
+```
+
+Claude Code orchestrates all 5 skills automatically!
+
+### Workflow 2: Feedback-Driven Skill Evolution
+
+Skills improve through usage:
+
+```javascript
+// After each execution, store metrics
+await reasoningbank.recordExecution({
+  skill: 'graphql-api-design',
+  task: 'user-service-schema',
+  approach: 'federation with dataloaders',
+  metrics: {
+    executionTime: '2.3s',
+    queryComplexity: 'optimized',
+    resolverEfficiency: '98%'
+  },
+  success: true,
+  feedback: 'Excellent performance, will use this pattern again'
+});
+
+// Next time: Skill adapts based on learned patterns
+```
+
+### Workflow 4: Team-Wide Skill Sharing and Customization
+
+#### Sharing Skills Across Your Team
+
+```bash
+# 1. Create team-specific skills in project directory
+cd /your-project
+npx agentic-flow skills init  # Creates .claude/skills/
+
+# 2. Generate team skills with skill-builder
+# Ask Claude Code:
+"Use skill-builder to create our team's API design standards skill.
+Include our preferred patterns: REST with OpenAPI, JWT auth,
+cursor pagination, and error handling standards."
+
+# 3. Commit to version control
+git add .claude/skills/
+git commit -m "feat: Add team API design standards skill"
+git push origin main
+
+# 4. Team members pull and use automatically
+git pull
+# Claude Code discovers team skills on next run
+```
+
+#### Customizing Sample Skills for Your Stack
+
+**Scenario**: You love the AgentDB vector search skill but use Python, not JavaScript.
+
+```bash
+# 1. Copy the sample skill
+cp -r .claude/skills/agentdb-vector-search \
+      .claude/skills/agentdb-python-search
+
+# 2. Edit and customize
+code .claude/skills/agentdb-python-search/SKILL.md
+```
+
+**Update code examples to Python:**
+```yaml
+---
+name: "AgentDB Vector Search (Python)"
+description: "Semantic vector search with AgentDB for Python projects.
+150x-12,500x performance improvement. Use for RAG systems and semantic search."
+---
+
+# AgentDB Vector Search (Python)
+
+## Quick Start
+
+### 1. Installation
+\`\`\`bash
+pip install agentdb
+\`\`\`
+
+### 2. Initialize
+\`\`\`python
+from agentdb import AgentDB
+
+db = AgentDB(
+    mode='python',
+    vector_dimensions=384,
+    enable_optimizations=True
+)
+\`\`\`
+
+### 3. Index Documents
+\`\`\`python
+# Generate embeddings
+from sentence_transformers import SentenceTransformer
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+docs = load_documents('./docs/**/*.md')
+for doc in docs:
+    embedding = model.encode(doc.content)
+    db.vector_db.insert(
+        embedding=embedding,
+        metadata={
+            'id': doc.id,
+            'title': doc.title,
+            'content': doc.content
+        }
+    )
+\`\`\`
+
+### 4. Semantic Search
+\`\`\`python
+query = "How do I implement authentication?"
+query_embedding = model.encode(query)
+
+results = db.vector_db.search(
+    query_embedding,
+    k=10,
+    threshold=0.7
+)
+
+for result in results:
+    print(f"{result.score:.2f} - {result.metadata['title']}")
+\`\`\`
+```
+
+**Now Claude Code applies Python patterns automatically:**
+```
+Implement semantic search for our Python documentation.
+```
+
+Claude discovers your customized Python skill and generates Python code!
+
+---
+
+#### Creating Organization-Wide Skill Library
+
+**For enterprises with multiple teams:**
+
+```bash
+# 1. Create organization skill repository
+git clone https://github.com/your-org/claude-skills.git ~/.claude/skills-org
+
+# 2. Symlink org skills to personal directory
+ln -s ~/.claude/skills-org/* ~/.claude/skills/
+
+# 3. Keep skills updated
+cd ~/.claude/skills-org
+git pull
+
+# Now all org skills available in all projects!
+```
+
+**Organization skill structure:**
+```
+~/.claude/skills-org/
+  ├── security/
+  │   ├── owasp-top-10/SKILL.md
+  │   └── security-review/SKILL.md
+  ├── api-design/
+  │   ├── rest-standards/SKILL.md
+  │   └── graphql-patterns/SKILL.md
+  ├── testing/
+  │   ├── unit-testing/SKILL.md
+  │   └── e2e-testing/SKILL.md
+  └── deployment/
+      ├── kubernetes-deploy/SKILL.md
+      └── ci-cd-pipeline/SKILL.md
+```
+
+**Benefits:**
+- ✅ Consistent standards across all teams
+- ✅ Centralized best practices
+- ✅ Easy updates (git pull)
+- ✅ Version controlled
+- ✅ Team-specific customization still possible
+
+---
+
+#### Publishing Skills to NPM (Advanced)
+
+**For skill creators who want to share with the community:**
+
+```bash
+# 1. Create skill package
+mkdir agentic-flow-skills-web3
+cd agentic-flow-skills-web3
+
+# 2. Package structure
+cat > package.json << 'EOF'
+{
+  "name": "agentic-flow-skills-web3",
+  "version": "1.0.0",
+  "description": "Claude Code skills for Web3 development",
+  "keywords": ["agentic-flow", "claude-code", "skills", "web3"],
+  "files": ["skills/"],
+  "scripts": {
+    "postinstall": "mkdir -p ~/.claude/skills && cp -r skills/* ~/.claude/skills/"
+  }
+}
+EOF
+
+# 3. Add your skills
+mkdir -p skills/
+cp -r .claude/skills/solidity-patterns skills/
+cp -r .claude/skills/smart-contract-security skills/
+
+# 4. Publish
+npm publish
+
+# 5. Users install with:
+npm install -g agentic-flow-skills-web3
+# Skills automatically copied to ~/.claude/skills/
+```
+
+---
+
+## 🛠️ Skill Builder Advanced Features
+
+### Template System
+
+Skill-builder includes 3 production templates:
+
+#### 1. Minimal Template (5 sections, ~100 lines)
+**Best for:** Simple, focused skills with single responsibility
+
+```yaml
+---
+name: "Code Formatter"
+description: "Format code with Prettier/ESLint standards."
+---
+
+# Code Formatter
+
+## What This Skill Does
+Applies consistent code formatting.
+
+## When to Use
+- Before committing code
+- Enforcing team standards
+
+## Quick Start
+[Basic formatting commands...]
+
+## Examples
+[2-3 code examples]
+
+## Learn More
+[Links to docs]
+```
+
+---
+
+#### 2. Full-Featured Template (12 sections, ~300 lines)
+**Best for:** Comprehensive skills with multiple use cases
+
+```yaml
+---
+name: "API Design Patterns"
+description: "Design REST/GraphQL APIs following industry best practices."
+---
+
+# API Design Patterns
+
+## What This Skill Does
+[Detailed description]
+
+## When to Use
+[5+ use cases]
+
+## Prerequisites
+[Requirements]
+
+## Quick Start
+[Getting started]
+
+## Step-by-Step Guide
+[Detailed walkthrough]
+
+## Advanced Patterns
+[Complex scenarios]
+
+## Best Practices
+[Industry standards]
+
+## Common Pitfalls
+[What to avoid]
+
+## Troubleshooting
+[Solutions to common issues]
+
+## Examples
+[10+ real-world examples]
+
+## Reference
+[Complete API docs]
+
+## Learn More
+[External resources]
+```
+
+---
+
+#### 3. Advanced Template (15+ sections, ~500 lines)
+**Best for:** Multi-agent coordination and complex workflows
+
+```yaml
+---
+name: "Full-Stack Application Builder"
+description: "Coordinate multiple agents to build complete applications."
+---
+
+# Full-Stack Application Builder
+
+## What This Skill Does
+[Orchestration overview]
+
+## Skill Dependencies
+- backend-api-design
+- frontend-react-patterns
+- database-optimization
+- testing-frameworks
+- deployment-automation
+
+## Multi-Agent Coordination
+[How agents collaborate]
+
+## Prerequisites
+[Tech stack requirements]
+
+## Architecture Overview
+[System design patterns]
+
+## Phase 1: Planning
+[Requirements analysis]
+
+## Phase 2: Backend Development
+[API implementation with coordination]
+
+## Phase 3: Frontend Development
+[UI implementation with coordination]
+
+## Phase 4: Integration
+[Connecting frontend + backend]
+
+## Phase 5: Testing
+[Comprehensive test strategy]
+
+## Phase 6: Deployment
+[CI/CD pipeline]
+
+## Agent Communication Patterns
+[How agents share context via AgentDB]
+
+## Learning & Optimization
+[ReasoningBank integration]
+
+## Monitoring & Observability
+[Performance tracking]
+
+## Troubleshooting
+[Debug multi-agent issues]
+
+## Examples
+[Complete application examples]
+```
+
+---
+
+### Validation System
+
+**Built-in validation checks:**
+
+```bash
+bash .claude/skills/skill-builder/scripts/validate-skill.sh my-skill/SKILL.md
+```
+
+**Checks performed:**
+1. ✅ **YAML Frontmatter**
+   - Valid YAML syntax
+   - Required fields (name, description)
+   - Field length limits
+   - No special characters
+
+2. ✅ **Markdown Structure**
+   - Proper heading hierarchy
+   - Code block formatting
+   - Link validity
+   - No broken references
+
+3. ✅ **Progressive Disclosure**
+   - Quick Start section exists
+   - Complexity increases gradually
+   - Advanced sections at end
+
+4. ✅ **Code Examples**
+   - Syntax highlighting specified
+   - No placeholder code
+   - Runnable examples
+
+5. ✅ **Security**
+   - No hardcoded secrets
+   - No sensitive data
+   - Safe command examples
+
+**Example validation output:**
+```
+🔍 Validating: microservice-patterns/SKILL.md
+═══════════════════════════════════════════════
+
+✓ YAML frontmatter: Valid
+  - name: "Microservice Patterns" (21 chars)
+  - description: 487 chars (max 1024)
+
+✓ Markdown structure: Valid
+  - 12 sections
+  - Proper heading hierarchy
+  - 18 code blocks
+
+✓ Progressive disclosure: Excellent
+  - Quick Start: 5 min read
+  - Step-by-Step: 15 min
+  - Advanced: 30+ min
+
+✓ Code examples: 18 found
+  - All have syntax highlighting
+  - All runnable
+
+✓ Security: No issues
+
+✅ Skill ready for use!
+
+Next steps:
+  1. Test with Claude Code
+  2. Share with team (git commit)
+  3. Publish to npm (optional)
+```
+
+---
+
+### Generation Scripts
+
+#### Interactive Generator
+
+```bash
+bash .claude/skills/skill-builder/scripts/generate-skill.sh
+```
+
+**Features:**
+- Guided prompts for all metadata
+- Template selection
+- Auto-validation
+- Section customization
+- Example code generation
+
+**Example session:**
+```
+🎨 agentic-flow Skill Generator
+═══════════════════════════════════════
+
+Let's create a new skill!
+
+Skill name: Database Query Optimization
+Description: Optimize SQL queries with indexing, query
+             planning, and performance analysis.
+
+Category:
+  1. api-design
+  2. testing
+  3. database       ← Selected
+  4. documentation
+  5. custom
+
+Template:
+  1. minimal        (Quick reference)
+  2. full-featured  ← Selected (Comprehensive guide)
+  3. advanced       (Multi-agent coordination)
+
+Include sections:
+  [✓] Quick Start
+  [✓] Prerequisites
+  [✓] Step-by-Step Guide
+  [✓] Examples (how many? 10)
+  [✓] Best Practices
+  [✓] Troubleshooting
+  [ ] Advanced Patterns (optional)
+
+Generate code examples?
+  Technology: PostgreSQL
+  Examples: [indexes, query plans, EXPLAIN ANALYZE]
+
+✓ Generating skill...
+✓ Adding 10 examples...
+✓ Validating...
+✓ Success!
+
+Created: .claude/skills/database-query-optimization/SKILL.md
+
+Test it:
+  "Optimize this slow database query: SELECT * FROM users..."
+```
+
+#### Batch Generator
+
+**Create multiple skills at once:**
+
+```bash
+bash .claude/skills/skill-builder/scripts/batch-generate.sh skills.yaml
+```
+
+**skills.yaml:**
+```yaml
+skills:
+  - name: "API Authentication"
+    description: "JWT, OAuth2, and session-based auth patterns"
+    template: full-featured
+    category: api-design
+
+  - name: "React Component Library"
+    description: "Build reusable React components"
+    template: full-featured
+    category: frontend
+
+  - name: "Docker Compose Workflows"
+    description: "Multi-container development environments"
+    template: minimal
+    category: devops
+```
+
+**Output:**
+```
+🎨 Batch Skill Generator
+═══════════════════════════════════════
+
+Processing 3 skills...
+
+✓ [1/3] API Authentication
+✓ [2/3] React Component Library
+✓ [3/3] Docker Compose Workflows
+
+All skills created successfully!
+
+Skills available:
+  • api-authentication
+  • react-component-library
+  • docker-compose-workflows
+
+Test them with Claude Code!
+```
+
+---
+
+### Testing Skills
+
+**Test script validates skill functionality:**
+
+```bash
+bash .claude/skills/skill-builder/scripts/test-skill.sh \
+     database-query-optimization/SKILL.md
+```
+
+**Test scenarios:**
+1. **Discovery Test**: Can Claude Code find the skill?
+2. **Activation Test**: Does it activate for relevant queries?
+3. **Execution Test**: Does it provide correct guidance?
+4. **Learning Test**: Does it store patterns in AgentDB?
+
+**Example output:**
+```
+🧪 Testing Skill: database-query-optimization
+═══════════════════════════════════════════════
+
+Test 1: Discovery
+  Query: "List installed skills"
+  ✓ Skill appears in list
+
+Test 2: Activation
+  Query: "Optimize this slow query"
+  ✓ Skill automatically activated
+
+Test 3: Execution
+  Query: "Add index to speed up user lookups"
+  ✓ Provided correct guidance
+  ✓ Generated runnable SQL
+  ✓ Explained trade-offs
+
+Test 4: Learning
+  ✓ Pattern stored in AgentDB
+  ✓ Confidence score: 0.92
+
+Test 5: Repeated Use
+  Query: "Optimize another user query"
+  ✓ Applied learned patterns
+  ✓ 38% faster than first execution
+
+✅ All tests passed!
+
+Skill performance:
+  - Activation rate: 95%
+  - Correctness: 100%
+  - Learning improvement: 38%
+```
+
+---
+
+## ✅ Best Practices
+
+### 1. **Skill Naming**
+```
+✅ Good: "GraphQL API Design"
+❌ Bad: "gql" or "api_design_123"
+
+✅ Good: "React Component Patterns"
+❌ Bad: "ReactStuff"
+```
+
+### 2. **Description Clarity**
+```yaml
+✅ Good:
+description: "Design GraphQL APIs with schema-first development,
+efficient resolvers, and federation. Use when building or
+refactoring GraphQL services."
+
+❌ Bad:
+description: "GraphQL stuff"
+```
+
+### 3. **Progressive Disclosure**
+```markdown
+✅ Good Structure:
+## Quick Start (5 minutes)
+Basic usage
+
+## Step-by-Step Guide (15 minutes)
+Detailed walkthrough
+
+## Advanced Patterns (30+ minutes)
+Complex scenarios
+
+## Reference
+Complete API docs
+```
+
+### 4. **Use AgentDB for Context**
+```javascript
+✅ Good:
+await reasoningbank.storePattern({
+  skill: 'api-design',
+  pattern: 'pagination',
+  approach: 'cursor-based',
+  performance: 'excellent'
+});
+
+❌ Bad:
+// No learning loop, patterns forgotten
+```
+
+### 5. **Skill Composition**
+```yaml
+✅ Good:
+# Reference other skills
+See also: `agentdb-vector-search`, `swarm-orchestration`
+
+❌ Bad:
+# Duplicate instructions from other skills
+```
+
+---
+
+## 🐛 Troubleshooting
+
+### Issue: Skills Not Discovered
+
+**Problem**: Claude Code doesn't find your skill.
+
+**Solutions**:
+```bash
+# 1. Verify skill location (MUST be top level!)
+ls ~/.claude/skills/          # Personal
+ls .claude/skills/            # Project
+
+# Should see: my-skill/SKILL.md
+# NOT: subdirectory/my-skill/SKILL.md
+
+# 2. Validate YAML frontmatter
+npx agentic-flow skills validate .claude/skills/my-skill/SKILL.md
+
+# 3. Restart Claude Code
+# Skills are loaded at startup
+
+# 4. Check file permissions
+chmod 644 .claude/skills/my-skill/SKILL.md
+```
+
+### Issue: Skill Executes Incorrectly
+
+**Problem**: Skill loads but doesn't work as expected.
+
+**Solutions**:
+```bash
+# 1. Check skill description matches use case
+npx agentic-flow skills list
+
+# 2. Add debugging context
+await reasoningbank.debug({
+  skill: 'my-skill',
+  context: 'What am I trying to do?',
+  expected: 'What should happen?',
+  actual: 'What actually happened?'
+});
+
+# 3. Review skill instructions
+cat .claude/skills/my-skill/SKILL.md
+```
+
+### Issue: Skills Conflict
+
+**Problem**: Multiple skills activate for same task.
+
+**Solution**:
+```yaml
+# Make descriptions more specific
+❌ description: "Build APIs"
+✅ description: "Build REST APIs with Express and TypeScript.
+                Use for traditional RESTful services, not GraphQL."
+```
+
+---
+
+## 🎯 Summary
+
+### What You Learned
+
+✅ **21 Built-In Skills** from claude-flow (AI, GitHub, Swarm, SPARC, Performance)
+✅ **Custom Skill Creation** with agentic-flow's skill-builder
+✅ **213+ MCP Tools** for coordination, memory, and automation
+✅ **54 Specialized Agents** for all development scenarios
+✅ **Dual-System Integration** combining pre-built + custom capabilities
+✅ **AgentDB + ReasoningBank** for persistent learning (46% faster over time)
+✅ **Skills compose and coordinate** for complex multi-agent workflows
+
+### Quick Reference
+
+#### claude-flow (Built-In Skills)
+```bash
+# Install and setup MCP server
+npm install -g claude-flow@alpha
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Verify 21 skills are available
+claude mcp list
+
+# Skills auto-discovered by Claude Code - no additional setup!
+```
+
+#### agentic-flow (Custom Skills)
+```bash
+# Initialize skill directories
+npx agentic-flow skills init
+
+# Create 4 sample skills
+npx agentic-flow skills create
+
+# List all skills (built-in + custom)
+npx agentic-flow skills list
+
+# Install skill builder framework
+npx agentic-flow skills init-builder
+
+# Validate custom skill
+npx agentic-flow skills validate <path>
+```
+
+#### Combined Usage
+```bash
+# Install both systems
+npm install -g claude-flow@alpha agentic-flow@latest
+
+# Setup MCP servers
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Create custom skills
+npx agentic-flow skills init
+npx agentic-flow skills create
+
+# Now you have:
+# ✅ 21 built-in claude-flow skills
+# ✅ 4 sample agentic-flow skills
+# ✅ 213+ MCP coordination tools
+# ✅ 54 specialized agents
+# ✅ Custom skill creation framework
+```
+
+### Skill Categories Available
+
+| Category | claude-flow Built-In | agentic-flow Custom | Total |
+|----------|---------------------|---------------------|-------|
+| AI & Memory | 3 | 2 | 5 |
+| GitHub Integration | 5 | 0 | 5 |
+| Swarm Orchestration | 4 | 1 | 5 |
+| Development & Quality | 3 | 0 | 3 |
+| Flow Nexus Platform | 3 | 0 | 3 |
+| **Total** | **21** | **4** | **25** |
+
+Plus unlimited custom skills you create!
+
+### Next Steps
+
+1. **Install claude-flow MCP**: Get 21 built-in skills instantly
+2. **Try built-in skills**: Test agentdb-vector-search, swarm-orchestration, github-code-review
+3. **Install agentic-flow**: Add custom skill creation capabilities
+4. **Create your first custom skill**: Use skill-builder for your domain
+5. **Build multi-agent workflows**: Combine claude-flow + custom skills
+6. **Explore MCP tools**: 213+ coordination tools available
+7. **Share with your team**: Commit custom skills to git
+8. **Join the community**: Share your skills on GitHub
+
+### Integration Patterns
+
+**Simple Task (1 skill):**
+```
+User: "Implement semantic search"
+→ agentdb-vector-search skill (built-in)
+→ Done in minutes
+```
+
+**Complex Task (multiple skills):**
+```
+User: "Build REST API with tests and deploy"
+→ sparc-methodology (planning)
+→ swarm-orchestration (parallel dev)
+→ agentdb-memory-patterns (coordination)
+→ github-workflow-automation (CI/CD)
+→ verification-quality (validation)
+→ reasoningbank-intelligence (learning)
+→ Complete production-ready system
+```
+
+**Custom Domain (built-in + custom):**
+```
+1. Use claude-flow built-in: swarm-orchestration
+2. Create custom: your-company-api-standards (agentic-flow)
+3. Combine: Company-specific development with best practices
+4. Learn: Patterns stored for 46% faster next time
+```
+
+---
+
+## 🌐 Resources
+
+### claude-flow
+- **Repository**: [https://github.com/ruvnet/claude-flow](https://github.com/ruvnet/claude-flow)
+- **Wiki**: [claude-flow wiki](https://github.com/ruvnet/claude-flow/wiki)
+- **21 Built-In Skills**: Available via MCP server
+- **213+ MCP Tools**: Coordination, memory, GitHub, neural patterns
+- **54 Agents**: Core dev to advanced distributed systems
+
+### agentic-flow
+- **Documentation**: [agentic-flow docs](https://github.com/ruvnet/agentic-flow/tree/main/docs)
+- **Examples**: [Example skills](https://github.com/ruvnet/agentic-flow/tree/main/examples)
+- **AgentDB**: [agentdb package](https://github.com/ruvnet/agentdb)
+- **skill-builder**: Custom skill creation framework
+- **Issues**: [GitHub Issues](https://github.com/ruvnet/agentic-flow/issues)
+
+### Official Anthropic
+- **Claude Code**: [Official docs](https://docs.claude.com/en/docs/claude-code)
+- **Claude Skills Specification**: [Skills guide](https://docs.claude.com/en/docs/claude-code/skills)
+- **Agent SDK**: [Agent development](https://docs.claude.com/en/docs/agent-sdk)
+
+---
+
+## 📊 Performance Metrics
+
+### With claude-flow + agentic-flow Integration:
+
+- **84.8% SWE-Bench solve rate** (vs industry avg 43%)
+- **32.3% token reduction** through intelligent coordination
+- **2.8-4.4x speed improvement** with parallel agent execution
+- **46% faster** on repeated tasks (ReasoningBank learning)
+- **150x-12,500x faster search** (AgentDB vector operations)
+- **27+ neural models** for pattern recognition
+- **0.95 accuracy threshold** for quality verification
+
+---
+
+**Version**: claude-flow v2.0 + agentic-flow v1.7.3
+**Philosophy**: Pre-built excellence + custom specialization
+**Architecture**: 21 built-in skills + unlimited custom + 213+ MCP tools
+**Result**: Enterprise-grade adaptive intelligence that learns how to think
+
+🚀 **Start building adaptive AI systems today:**
+
+```bash
+# Full installation (recommended)
+npm install -g claude-flow@alpha agentic-flow@latest
+
+# Setup MCP server for built-in skills
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Create custom skills
+npx agentic-flow skills init
+npx agentic-flow skills create
+npx agentic-flow skills init-builder
+
+# You now have access to:
+# ✅ 21 claude-flow built-in skills
+# ✅ 4 agentic-flow sample skills
+# ✅ 213+ MCP coordination tools
+# ✅ 54 specialized agents
+# ✅ Custom skill creation framework
+# ✅ AgentDB vector memory
+# ✅ ReasoningBank pattern learning
+# ✅ SPARC methodology
+# ✅ Complete GitHub integration
+
+# Ready to build production AI systems! 🎯
+```