v2/docs/guides/skills-tutorial.md
Weβre shifting how Claude Flow evolves from here forward. This release marks the move from slash commands to a true skills-based system, our new foundation for intelligence, automation, and collaboration. Instead of memorizing /commands, you now just describe what you want. Claude reads the situation, identifies the right skills, and activates them automatically.
The new Skill Builder is at the heart of this system. It lets you create modular instruction sets, small, well-defined units of capability that can be shared, versioned, and composed. Each skill is a self-contained block of context with metadata, description, and progressive disclosure. Claude scans these on startup, loads whatβs relevant, and builds the workflow around your intent.
We've included 25 practical skills across development, teamwork, and reasoning. SPARC Methodology guides structured feature building through five phases with TDD. Pair Programming enables driver/navigator modes with real-time quality checks. AgentDB provides persistent memory with 150x faster pattern retrieval and vector search. Swarm Orchestration coordinates parallel multi-agent work across mesh, hierarchical, and ring topologies. GitHub skills automate code reviews, releases, and multi-repo synchronization. Others handle performance optimization, truth scoring, and adaptive learning patterns.
There are GitHub skills that manage reviews, automate releases, and synchronize projects. Others focus on performance, quality verification, and adaptive learning through ReasoningBank.
In practice, this means no memorization. Skills scan your request, match intent to capability, and load only what's needed. Say "Build a login feature with tests" and SPARC activates. Say "Find similar code" and vector search loads. Each skill brings specialized context on-demand, keeping your workflow clean and focused.
This is the direction forward: modular, intelligent, and adaptive. Skills turn Claude Flow from a set of commands into a living system that learns how you work and grows with you.
I'm transitioning claude-flow from slash commands to Claude Code's native skills system. Here's why this matters and what I've learned.
Previously, claude-flow used slash commands stored in .claude/commands/:
# Old approach
/.claude/commands/sparc-tdd.md
/.claude/commands/github-review.md
/.claude/commands/swarm-init.md
When you typed /sparc-tdd, Claude would load that markdown file as a prompt and execute it. This worked, but had limitations:
Issues I Found:
Anthropic released the skills API in October 2025, and I immediately saw the potential. Skills solve the command problems elegantly:
# New approach
/.claude/skills/sparc-methodology/SKILL.md
/.claude/skills/github-code-review/SKILL.md
/.claude/skills/swarm-orchestration/SKILL.md
Each skill has YAML frontmatter with metadata:
---
name: sparc-methodology
description: SPARC development methodology for systematic feature building
tags: [development, tdd, methodology]
category: development
---
Why This Is Better (In My Opinion):
Automatic Discovery: Claude scans skills at startup, reads the metadata, and only loads full content when relevant. A task about "building a feature with tests" automatically triggers SPARC methodology - no slash command needed.
Progressive Disclosure: Skills use a tiered structure (overview β details β advanced). Claude gets just enough information to decide if it's useful, then loads more if needed. This keeps context clean.
Composability: Skills can reference other skills. The GitHub review skill can use swarm orchestration internally without you knowing or caring. Commands couldn't do this well.
Organization: Skills live in categorized directories (development/, github/, memory/). Much easier to maintain than a flat commands folder.
Standards-Based: Anthropic designed this. It works across Claude.ai, Claude Code CLI, and any other Claude implementation. Commands were claude-flow specific.
I'm not removing commands immediately - that would break existing workflows. Instead:
If you're using commands like /sparc tdd, they still work. But I recommend switching to skills:
# Instead of this:
/sparc tdd "feature name"
# Do this:
npx claude-flow@alpha init --force # Install skills
# Then just ask: "Build a user authentication feature with TDD"
# The SPARC skill activates automatically
What Skills Do Better:
What Commands Did Better:
/command, it runsThe Trade-off:
Skills are more sophisticated but less explicit. Sometimes I miss the directness of /command - you knew what you were getting. With skills, Claude decides when to activate them. Usually it gets it right, but occasionally it misses or over-activates.
That said, the context savings and automatic discovery outweigh the loss of explicitness. And you can still manually invoke skills with /skill-name if you want that control.
Skills are the future of claude-flow. They align with Anthropic's vision, work better with Claude Code, and solve real problems I had with commands. The migration takes effort, but it's worth it.
If you're starting fresh, use skills. If you're on commands, plan to migrate. I'll support both for now, but my development focus is on skills.
This release adds 4 new AgentDB skills that bring production-grade vector database capabilities to claude-flow:
Performance Improvements:
New Skills:
reasoningbank-agentdb - ReasoningBank with AgentDB backend
agentdb-learning - 9 Reinforcement Learning Algorithms
agentdb-optimization - Performance Tuning
agentdb-advanced - Enterprise Features
Why AgentDB?
The original vector search and memory systems used ChromaDB and legacy ReasoningBank. While functional, they had performance limitations at scale. AgentDB provides:
These skills work alongside the existing agentdb-memory-patterns and agentdb-vector-search skills, giving you a complete vector database toolkit.
Claude Flow includes 25 specialized skills that activate automatically based on your task description. Just describe what you want in natural language - no commands needed.
skill-builder - Create custom Claude Code skills with YAML frontmatter and progressive disclosuresparc-methodology - SPARC development methodology (Specification, Pseudocode, Architecture, Refinement, Completion) with TDDpair-programming - Driver/navigator pair programming with real-time verification and quality monitoringagentdb-memory-patterns - Persistent agent memory with session storage and long-term context managementagentdb-vector-search - Semantic vector search for intelligent document retrieval and similarity matchingreasoningbank-agentdb - ReasoningBank with 150x-12,500x faster AgentDB backend for experience learningagentdb-learning - 9 reinforcement learning algorithms (Decision Transformer, Q-Learning, SARSA, Actor-Critic, etc.)agentdb-optimization - Performance optimization with quantization (4-32x compression) and HNSW indexingagentdb-advanced - QUIC synchronization, multi-database management, custom metrics, hybrid searchswarm-orchestration - Multi-agent swarm coordination with parallel task execution and dynamic topologyswarm-advanced - Advanced swarm patterns for research, development, testing, and complex workflowshive-mind-advanced - Queen-led hierarchical coordination with consensus mechanisms and persistent memorygithub-code-review - AI-powered comprehensive code reviews with multi-agent analysisgithub-workflow-automation - Intelligent CI/CD pipeline creation and optimization with GitHub Actionsgithub-project-management - Issue tracking, project board automation, and sprint planninggithub-release-management - Release orchestration with versioning, testing, deployment, and rollbackgithub-multi-repo - Cross-repository synchronization and multi-package integrationhooks-automation - Pre/post task hooks with automated formatting, learning, and session managementverification-quality - Truth scoring and automatic rollback with 0.95 accuracy thresholdperformance-analysis - Bottleneck detection and optimization recommendations for workflowsstream-chain - Stream-JSON chaining for multi-agent pipelines and data transformationflow-nexus-platform - Cloud platform management (authentication, sandboxes, apps, payments)flow-nexus-swarm - Cloud-based AI swarm deployment with event-driven workflow automationflow-nexus-neural - Distributed neural network training in E2B sandboxes with cloud computereasoningbank-intelligence - Adaptive learning with pattern recognition and strategy optimizationnpx claude-flow@alpha init --force Do?This command initializes your project with Claude Flow's complete skills system:
What It Does:
.claude/skills/ directory - Where all 25 skills are installedclaude-flow.json with default settings--force flag replaces existing files (useful for updates)When to Use It:
--force)Usage:
# Initialize in current project
npx claude-flow@alpha init --force
# What you'll see:
# β Created .claude/skills/ directory
# β Installed 25 skills
# β Configured hooks automation
# β Setup statusline integration
# β Ready to use skills!
After Installation:
/agentdb-vector-searchskill-builder - Create Your Own SkillsWhat It Does: Helps you create custom Claude Code skills with proper structure, YAML frontmatter, and progressive disclosure.
When to Use:
Plain Language: Think of it as a "skill factory" - it teaches Claude how to build new skills that other Claude instances can discover and use.
Usage:
# Natural language invocation - skill activates automatically
"Create a new skill for React component development following our team's patterns"
"Build a custom skill for API endpoint testing with our authentication flow"
"Help me make a skill that knows our database schema conventions"
# The skill-builder skill activates when you mention creating/building skills
What You Get:
SKILL.md file.claude/skills/sparc-methodology - Systematic DevelopmentWhat It Does: Implements SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) - a five-phase development methodology for building features systematically.
When to Use:
Plain Language: SPARC breaks development into five steps: (1) Define what you need, (2) Write algorithm logic, (3) Design the system, (4) Build with tests, (5) Integrate everything. It prevents "code first, think later" problems.
Usage:
# Full SPARC workflow
npx claude-flow sparc tdd "user authentication system"
# Individual phases
npx claude-flow sparc run spec-pseudocode "shopping cart feature"
npx claude-flow sparc run architect "payment processing"
# Check available modes
npx claude-flow sparc modes
What You Get:
pair-programming - AI Pair ProgrammingWhat It Does: Provides driver/navigator pair programming modes with real-time verification, quality monitoring, and automatic role switching.
When to Use:
Plain Language: Like having an experienced developer sitting next to you. Claude can "drive" (write code while you watch) or "navigate" (guide you while you code). Roles can switch automatically, and there's continuous quality checking.
Usage:
# Natural language invocation - skill activates automatically
"Let's pair program on this React component - you drive first"
"Switch to navigator mode and review my authentication code"
"I need help debugging - this function isn't working as expected"
# The skill activates when you mention pair programming or collaborative coding
Modes Available:
agentdb-memory-patterns - Persistent Agent MemoryWhat It Does: Implements persistent memory patterns for AI agents - session memory, long-term storage, pattern learning, and context management.
When to Use:
Plain Language: Gives Claude a "long-term memory" that survives beyond single conversations. Like taking notes that Claude can reference later, even in different sessions.
Usage:
# Natural language invocation - skill activates automatically
"Store our API design decisions in long-term memory"
"Remember this user's preferences for future sessions"
"Create a memory pattern for tracking bug fixes"
# The skill activates when you mention memory, persistence, or storing context
Memory Types:
agentdb-vector-search - Semantic SearchWhat It Does: Implements semantic vector search for intelligent document retrieval, similarity matching, and context-aware querying.
When to Use:
Plain Language: Instead of searching for exact word matches, this searches by meaning. Ask "how do we handle errors?" and it finds relevant code even if it doesn't contain those exact words.
Usage:
# Natural language invocation - skill activates automatically
"Find all code that handles user authentication"
"Search for functions similar to calculateDiscount()"
"Use vector search to retrieve documentation about error handling patterns"
# The skill activates when you mention semantic search, finding similar code, or vector search
What You Get:
reasoningbank-agentdb - ReasoningBank IntegrationWhat It Does: Implements ReasoningBank adaptive learning with AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time.
When to Use:
Plain Language: ReasoningBank teaches agents to learn from their experiences. Every time an agent completes a task, it stores what worked, what didn't, and why. Next time it faces a similar problem, it recalls successful patterns and avoids failures. AgentDB makes this 150x faster than before.
Usage:
# Natural language invocation - skill activates automatically
"Setup ReasoningBank with AgentDB for this project"
"Remember this bug fix approach for future similar issues"
"Migrate existing ReasoningBank data to AgentDB"
# The skill activates when you mention ReasoningBank, learning from experiences, or pattern tracking
Performance Benefits:
Key Features:
agentdb-learning - Learning Plugins & AlgorithmsWhat It Does: Provides 9 reinforcement learning algorithms via AgentDB's plugin system. Create, train, and deploy learning plugins for autonomous agents that improve through experience - includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more.
When to Use:
Plain Language: Instead of programming every behavior, you train agents to learn optimal strategies through trial and error. Like teaching a dog tricks - reward good behavior, correct mistakes, and the agent learns what works best.
Usage:
# Natural language invocation - skill activates automatically
"Create a Decision Transformer plugin for code optimization tasks"
"Train a Q-Learning agent on our deployment success/failure data"
"Show me all available learning plugin templates"
# The skill activates when you mention reinforcement learning, training agents, or learning algorithms
Available Algorithms:
Decision Transformer (Recommended)
Q-Learning
SARSA
Actor-Critic
Curiosity-Driven
Training Performance:
agentdb-optimization - Performance OptimizationWhat It Does: Comprehensive performance optimization for AgentDB vector databases - quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching strategies, and batch operations.
When to Use:
Plain Language: Makes vector databases smaller and faster. Binary quantization compresses vectors by 32x (3GB becomes 96MB) with minimal accuracy loss. HNSW indexing makes searches 150x faster. Like compressing a movie file - it takes less space and loads faster, but you barely notice the quality difference.
Usage:
# Natural language invocation - skill activates automatically
"Benchmark my AgentDB performance"
"Optimize this database with binary quantization for production"
"Analyze memory usage and suggest optimizations"
# The skill activates when you mention optimization, performance, quantization, or benchmarking
Optimization Techniques:
1. Binary Quantization (32x Compression)
2. Scalar Quantization (4x Compression)
3. HNSW Indexing
4. Caching Strategies
Performance Numbers:
agentdb-advanced - Advanced FeaturesWhat It Does: Master advanced AgentDB capabilities - QUIC synchronization (<1ms cross-node), multi-database management, custom distance metrics, hybrid search (vector + metadata), and distributed systems integration.
When to Use:
Plain Language: Advanced features for production systems. QUIC sync lets multiple databases stay synchronized with sub-millisecond latency - like having a shared brain across multiple servers. Hybrid search combines semantic similarity with filters (find similar code, but only Python files modified this month).
Usage:
# Natural language invocation - skill activates automatically
"Setup QUIC sync between 3 database nodes"
"Search for similar authentication code, but only in TypeScript files"
"Use cosine similarity for text, Euclidean for embeddings"
# The skill activates when you mention QUIC, distributed sync, hybrid search, or custom metrics
Advanced Capabilities:
1. QUIC Synchronization
2. Multi-Database Management
3. Custom Distance Metrics
4. Hybrid Search
Example QUIC Deployment:
// Node 1 syncs with Nodes 2 & 3
const db1 = await createAdapter({
enableQUICSync: true,
syncPeers: ['node2:4433', 'node3:4433'],
});
// Pattern inserted on Node 1
await db1.insertPattern({ /* ... */ });
// Available on Nodes 2 & 3 within ~1ms
Performance:
reasoningbank-intelligence - Adaptive LearningWhat It Does: Implements adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement.
When to Use:
Plain Language: Claude learns from experience. If a certain approach works well, it remembers and uses it again. If something fails, it learns to avoid that pattern.
Usage:
# Natural language invocation - skill activates automatically
"Learn from this successful deployment and optimize future ones"
"Analyze our testing patterns and suggest improvements"
"Remember this bug fix strategy for similar issues"
# The skill activates when you mention adaptive learning, pattern recognition, or strategy optimization
Capabilities:
swarm-orchestration - Multi-Agent CoordinationWhat It Does: Orchestrates multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination.
When to Use:
Plain Language: Instead of one Claude doing everything, this spawns multiple specialized Claudes working together. One might research while another codes, another tests - all in parallel.
Usage:
# Natural language invocation - skill activates automatically
"Create a swarm to build a REST API - researcher, coder, tester, reviewer"
"Orchestrate parallel agents for frontend, backend, and database work"
"Spawn a swarm to analyze this codebase from multiple angles"
# The skill activates when you mention swarms, multi-agent coordination, or parallel agents
Topologies:
swarm-advanced - Advanced Swarm PatternsWhat It Does: Advanced swarm patterns for research, development, testing, and complex distributed workflows.
When to Use:
Plain Language: Takes swarm orchestration to the next level with specialized patterns for specific workflows - research swarms dig deep into topics, development swarms handle full SDLC, testing swarms verify from multiple angles.
Usage:
# Natural language invocation - skill activates automatically
"Launch a research swarm to analyze market trends in our domain"
"Deploy a development swarm for microservices architecture"
"Create a testing swarm with unit, integration, and E2E specialists"
# The skill activates when you mention advanced swarm patterns, research swarms, or complex workflows
Patterns:
hive-mind-advanced - Collective IntelligenceWhat It Does: Queen-led hierarchical multi-agent coordination with consensus mechanisms and persistent memory.
When to Use:
Plain Language: A "queen bee" agent coordinates specialized "worker" agents. The queen makes strategic decisions, workers execute tasks, and they reach consensus through voting mechanisms.
Usage:
# Natural language invocation - skill activates automatically
"Deploy a hive mind for our microservices migration project"
"Create a queen coordinator with worker agents for each service"
"Use consensus for architectural decisions"
# The skill activates when you mention hive mind, queen coordinator, or consensus-based coordination
Structure:
github-code-review - AI Code ReviewsWhat It Does: Deploy specialized AI agents for comprehensive, intelligent code reviews beyond traditional static analysis.
When to Use:
Plain Language: Multiple AI reviewers examine your code from different angles: one checks security, another performance, another readability. Like having a senior dev team review every PR.
Usage:
# Natural language invocation - skill activates automatically
"Review PR #42 in this repository"
"Analyze security vulnerabilities in the authentication module"
"Check code quality and suggest improvements"
# The skill activates when you mention PR review, code review, or security analysis
Review Types:
github-workflow-automation - CI/CD IntelligenceWhat It Does: Creates intelligent, self-organizing CI/CD pipelines with adaptive multi-agent coordination and automated optimization.
When to Use:
Plain Language: Builds smart CI/CD pipelines that adapt to your project. They learn which tests fail often, optimize build times, and automatically handle common deployment patterns.
Usage:
# Natural language invocation - skill activates automatically
"Create a GitHub Actions workflow for Node.js testing and deployment"
"Optimize our existing CI pipeline for faster builds"
"Setup automated releases with semantic versioning"
# The skill activates when you mention GitHub Actions, CI/CD, or workflow automation
Features:
github-project-management - Project CoordinationWhat It Does: Swarm-coordinated issue tracking, project board automation, and sprint planning.
When to Use:
Plain Language: Automates project management tasks - triages issues, updates project boards, tracks sprint progress, and coordinates team work using AI swarms.
Usage:
# Natural language invocation - skill activates automatically
"Triage all open issues and categorize by priority"
"Update project board based on PR statuses"
"Plan next sprint based on velocity and priorities"
# The skill activates when you mention issue triage, project boards, or sprint planning
Capabilities:
github-release-management - Release OrchestrationWhat It Does: Orchestrates complex releases using AI swarms for automated versioning, testing, deployment, and rollback management.
When to Use:
Plain Language: Manages the entire release process - bumps versions, generates changelogs, runs tests, deploys to environments, and can rollback if issues occur.
Usage:
# Natural language invocation - skill activates automatically
"Create a new release v2.1.0 with changelog"
"Deploy to staging and run smoke tests"
"Rollback production to previous version"
# The skill activates when you mention releases, deployment, changelogs, or rollback
Release Steps:
github-multi-repo - Cross-Repository SyncWhat It Does: Cross-repository synchronization, version alignment, and multi-package integration with intelligent swarm orchestration.
When to Use:
Plain Language: Coordinates changes across multiple repositories - updates versions together, syncs dependencies, propagates changes, and ensures everything stays compatible.
Usage:
# Natural language invocation - skill activates automatically
"Sync dependency versions across all our microservice repos"
"Propagate this API change to all consuming packages"
"Update shared configuration across the organization"
# The skill activates when you mention multi-repo, cross-repository, or dependency sync
Sync Types:
hooks-automation - Development AutomationWhat It Does: Automated coordination, formatting, and learning from Claude Code operations using intelligent hooks with MCP integration.
When to Use:
Plain Language: Hooks automatically run before/after operations. Save a file β auto-format. Complete a task β update memory. End session β export metrics. Like Git hooks, but for AI development.
Usage:
# Natural language invocation - skill activates automatically
"Setup pre-commit hooks for code formatting"
"Configure post-task hooks to update documentation"
"Enable session hooks for metric collection"
# The skill activates when you mention hooks, automation, or pre/post task operations
Hook Types:
verification-quality - Quality AssuranceWhat It Does: Comprehensive truth scoring, code quality verification, and automatic rollback with 0.95 accuracy threshold.
When to Use:
Plain Language: Every change gets a "truth score" (0-1 accuracy rating). If it scores below 0.95, changes are automatically rolled back. Prevents low-quality code from entering your codebase.
Usage:
# Natural language invocation - skill activates automatically
"Run quality verification on recent changes"
"Check truth scores for this PR"
"Setup automatic rollback for low-quality commits"
# The skill activates when you mention quality verification, truth scoring, or automatic rollback
Verification Types:
performance-analysis - Bottleneck DetectionWhat It Does: Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms.
When to Use:
Plain Language: Analyzes why operations are slow, identifies bottlenecks (network, CPU, memory, coordination), and suggests optimizations.
Usage:
# Natural language invocation - skill activates automatically
"Why is my swarm running slowly?"
"Identify bottlenecks in this workflow"
"Suggest optimizations for faster execution"
# The skill activates when you mention performance, bottlenecks, or optimization analysis
Analysis Areas:
stream-chain - Pipeline ProcessingWhat It Does: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows.
When to Use:
Plain Language: Chains agents together like Unix pipes - output from one agent flows as input to the next. Great for ETL, data processing, and sequential transformations.
Usage:
# Natural language invocation - skill activates automatically
"Chain: fetch data β transform β validate β store"
"Pipeline: parse logs β analyze errors β generate report"
"Stream: read files β extract data β aggregate β visualize"
# The skill activates when you mention pipelines, chaining, or stream processing
Pipeline Stages:
flow-nexus-platform - Cloud PlatformWhat It Does: Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges.
When to Use:
Plain Language: Access to Flow Nexus cloud platform - create isolated sandboxes for testing, deploy apps, manage authentication, and access 70+ cloud tools.
Usage:
# Natural language invocation - skill activates automatically
"Create a sandbox for testing this Node.js app"
"Deploy my application to Flow Nexus"
"Setup authentication for cloud access"
# The skill activates when you mention Flow Nexus, cloud platform, or sandboxes
Features:
flow-nexus-swarm - Cloud SwarmsWhat It Does: Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform.
When to Use:
Plain Language: Runs swarms in the cloud instead of locally. Scale to hundreds of agents, handle events, and process distributed workloads without local resource limits.
Usage:
# Natural language invocation - skill activates automatically
"Deploy a 50-agent swarm in the cloud for this analysis"
"Create event-driven workflow for CI/CD"
"Scale swarm to handle high-volume processing"
# The skill activates when you mention cloud swarms, event-driven workflows, or distributed processing
Cloud Features:
flow-nexus-neural - Cloud Neural TrainingWhat It Does: Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus.
When to Use:
Plain Language: Train machine learning models in the cloud using distributed sandboxes. No need for local GPUs - Flow Nexus handles the compute.
Usage:
# Natural language invocation - skill activates automatically
"Train a neural network for code classification"
"Deploy distributed training across 10 sandboxes"
"Run inference on this trained model"
# The skill activates when you mention neural training, distributed ML, or cloud compute
Capabilities:
Natural Language Invocation - Skills activate automatically based on your task description. Just describe what you want to do in plain language:
# No slash commands needed - just describe your task
"Let's pair program on this component" β Activates pair-programming
"Review this PR for security issues" β Activates github-code-review
"Create a swarm to build this API" β Activates swarm-orchestration
"Use vector search to find similar functions" β Activates agentdb-vector-search
Skills activate automatically when:
You don't need to know skill names - just describe what you want, and the right skills activate.
New Feature Development:
"Build a user authentication feature with TDD"
# β Activates sparc-methodology for systematic development
Code Review:
"Review PR #42 for security and performance issues"
# β Activates github-code-review with multi-agent analysis
Performance Issues:
"Why is my workflow running slowly? Find bottlenecks"
# β Activates performance-analysis for optimization
Team Coordination:
"Create a swarm with frontend, backend, and testing specialists"
# β Activates swarm-orchestration for parallel multi-agent work
Search & Memory:
"Find code similar to this authentication pattern"
# β Activates agentdb-vector-search for semantic search
npx claude-flow@alpha init --forceRemember: Just describe what you want in natural language - no commands to memorize!
Remember: Skills are discovered automatically - just start working, and Claude will use the right skills at the right time!