Add 260+ Claude Code skills from skills.sh

Complete collection of AI agent skills including: - Frontend Development (Vue, React, Next.js, Three.js) - Backend Development (NestJS, FastAPI, Node.js) - Mobile Development (React Native, Expo) - Testing (E2E, frontend, webapp) - DevOps (GitHub Actions, CI/CD) - Marketing (SEO, copywriting, analytics) - Security (binary analysis, vulnerability scanning) - And many more... Synchronized from: https://skills.sh/ Co-Authored-By: Claude <noreply@anthropic.com>
2026-01-23 18:02:28 +00:00
commit 07242683bf
3300 changed files with 1223105 additions and 0 deletions
--- a/cognitive-planner/SKILL.md
+++ b/cognitive-planner/SKILL.md
@@ -0,0 +1,436 @@
+---
+name: cognitive-planner
+description: "Autonomous task planning and action selection for Claude Code. Analyzes context, breaks down complex tasks, selects optimal execution strategies, and coordinates with other skills like Superpowers."
+
+version: "1.0.0"
+author: "Adapted from HighMark-31/Cognitive-User-Simulation"
+
+# COGNITIVE PLANNER SKILL
+
+## CORE MANDATE
+
+This skill provides **autonomous planning and action selection** for Claude Code. It works WITH other skills (like Superpowers) to provide intelligent task breakdown and execution strategy.
+
+## WHEN TO ACTIVATE
+
+This skill activates automatically when:
+- User requests building/creating something complex
+- Task requires multiple steps or approaches
+- User asks "how should I..." or "what's the best way to..."
+- Complex problem solving is needed
+- Task coordination would benefit from planning
+
+## COGNIVE PLANNING PROCESS
+
+### Phase 1: CONTEXT ANALYSIS
+
+Before ANY action, analyze:
+
+```
+1. TASK TYPE: What kind of task is this?
+   - Feature implementation
+   - Bug fixing
+   - Refactoring
+   - Testing
+   - Documentation
+   - Deployment
+   - Research/Exploration
+
+2. COMPLEXITY LEVEL: How complex is this?
+   - SIMPLE: Single file, <50 lines, straightforward logic
+   - MODERATE: 2-5 files, 50-200 lines, some interdependencies
+   - COMPLEX: 5+ files, 200+ lines, many dependencies
+   - VERY COMPLEX: Architecture changes, multiple systems
+
+3. CONTEXT FACTORS:
+   - What's the tech stack?
+   - Are there existing patterns in the codebase?
+   - What skills/plugins are available?
+   - What are the constraints (time, resources, permissions)?
+   - What does success look like?
+```
+
+### Phase 2: ACTION SELECTION
+
+Based on analysis, select optimal approach:
+
+```
+IF SIMPLE TASK:
+  → Direct execution (no planning needed)
+  → Just do it efficiently
+
+IF MODERATE TASK:
+  → Quick plan (2-3 steps)
+  → Consider Superpowers if writing code
+  → Execute with checkpoints
+
+IF COMPLEX TASK:
+  → Detailed plan with steps
+  → Activate relevant Superpowers skills
+  → Use Test-Driven Development
+  → Set up verification checkpoints
+
+IF VERY COMPLEX TASK:
+  → Comprehensive planning
+  → Consider multiple approaches
+  → Present options to user
+  → Break into phases
+  → Use systematic methodologies
+```
+
+### Phase 3: SUPERPOWERS INTEGRATION
+
+Coordinate with Superpowers plugin:
+
+```
+TASK TYPE → SUPERPOWERS SKILL
+
+Feature Implementation:
+  → /brainstorm (explore options)
+  → /superpowers:write-plan (create plan)
+  → /superpowers:execute-plan (TDD execution)
+
+Bug Fixing:
+  → /superpowers:debug-plan (systematic debugging)
+  → /superpowers:execute-plan (fix & verify)
+
+Refactoring:
+  → /brainstorm (approaches)
+  → /superpowers:write-plan (refactor plan)
+  → /superpowers:execute-plan (TDD refactor)
+
+Research/Exploration:
+  → /brainstorm (what to investigate)
+  → Plan exploration approach
+  → Document findings
+```
+
+### Phase 4: EXECUTION STRATEGY
+
+Determine HOW to execute:
+
+```
+FOR CODE TASKS:
+  1. Check if tests exist → If no, write tests first
+  2. Read existing code → Understand patterns
+  3. Implement → Following codebase style
+  4. Test → Verify functionality
+  5. Document → If complex
+
+FOR CONFIGURATION:
+  1. Backup current config
+  2. Make changes
+  3. Verify settings
+  4. Test functionality
+
+FOR DEBUGGING:
+  1. Reproduce issue
+  2. Isolate location
+  3. Identify root cause
+  4. Fix with test
+  5. Verify fix
+```
+
+## COGNITIVE ENHANCEMENTS
+
+### Interest Level Tracking
+
+Just like the Discord bot tracks interest, track task relevance:
+
+```
+HIGH INTEREST (>0.7):
+  → User explicitly requested
+  → Clear requirements provided
+  → Active participation
+
+MEDIUM INTEREST (0.3-0.7):
+  → Implicit request
+  → Some ambiguity
+  → Need validation
+
+LOW INTEREST (<0.3):
+  → Assumption required
+  → High uncertainty
+  → MUST ask clarifying questions
+```
+
+### Mood & Personality Adaptation
+
+Adapt planning style based on context:
+
+```
+TECHNICAL TASKS:
+  Mood: 'focused'
+  Personality: 'precise, systematic, thorough'
+  Approach: Methodical, detail-oriented
+
+CREATIVE TASKS:
+  Mood: 'exploratory'
+  Personality: 'curious, experimental, open-minded'
+  Approach: Brainstorm options, iterate
+
+URGENT TASKS:
+  Mood: 'efficient'
+  Personality: 'direct, pragmatic, results-oriented'
+  Approach: Fast, minimal viable solution
+```
+
+### Language & Tone Detection
+
+Adapt communication style:
+
+```
+TECHNICAL USERS:
+  → Use technical terminology
+  → Provide implementation details
+  → Show code examples
+
+BEGINNER USERS:
+  → Use simpler language
+  → Explain concepts
+  → Provide step-by-step guidance
+
+BUSINESS USERS:
+  → Focus on outcomes
+  → Minimize technical jargon
+  → Highlight business value
+```
+
+## PLANNING TEMPLATE
+
+When creating a plan, use this structure:
+
+```markdown
+## 🎯 Objective
+[Clear statement of what we're accomplishing]
+
+## 📊 Complexity Assessment
+- **Type**: [Feature/Bug/Refactor/etc]
+- **Level**: [Simple/Moderate/Complex/Very Complex]
+- **Risk**: [Low/Medium/High]
+
+## 🤔 Approach Options
+1. **Option 1**: [Description]
+   - Pros: [advantages]
+   - Cons: [disadvantages]
+   - Estimation: [complexity]
+
+2. **Option 2**: [Description]
+   - Pros: [advantages]
+   - Cons: [disadvantages]
+   - Estimation: [complexity]
+
+## ✅ Recommended Approach
+[Selected option with justification]
+
+## 📋 Execution Plan
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+...
+
+## 🔍 Verification
+[How we'll know it's complete]
+
+## 🚀 Next Steps
+[Immediate actions]
+```
+
+## INTEGRATION EXAMPLES
+
+### Example 1: User requests "Add user authentication"
+
+```
+COGNITIVE PLANNER ANALYSIS:
+
+TASK TYPE: Feature Implementation
+COMPLEXITY: COMPLEX (security critical, multiple files)
+CONTEXT: Web application, needs secure auth
+
+INTEREST LEVEL: MEDIUM (need clarification on:
+  - What auth method? (JWT, sessions, OAuth)
+  - What providers? (local, Google, GitHub)
+  - What user model? (email, username, etc.)
+
+ACTION: Ask clarifying questions before planning
+```
+
+### Example 2: User requests "Fix the login bug"
+
+```
+COGNITIVE PLANNER ANALYSIS:
+
+TASK TYPE: Bug Fixing
+COMPLEXITY: MODERATE (need to reproduce first)
+CONTEXT: Existing auth system has issue
+
+INTEREST LEVEL: HIGH (explicit request)
+
+ACTION SELECTION:
+  1. Use /superpowers:debug-plan for systematic debugging
+  2. Follow 4-phase process (Reproduce → Isolate → Root Cause → Fix)
+  3. Add test to prevent regression
+
+EXECUTION: Proceed with Superpowers debugging workflow
+```
+
+### Example 3: User requests "Redesign the homepage"
+
+```
+COGNITIVE PLANNER ANALYSIS:
+
+TASK TYPE: Creative/Feature
+COMPLEXITY: MODERATE (visual + code)
+CONTEXT: Frontend changes, UI/UX involved
+
+INTEREST LEVEL: MEDIUM (need clarification on:
+  - What's the goal? (conversion, branding, usability)
+  - Any design preferences?
+  - Mobile-first? Desktop-first?
+  - Any examples to reference?)
+
+ACTION SELECTION:
+  → Ask clarifying questions first
+  → Consider using ui-ux-pro-max skill for design
+  → Plan implementation after requirements clear
+
+MOOD: 'exploratory'
+PERSONALITY: 'creative, user-focused, iterative'
+```
+
+## SPECIAL FEATURES
+
+### Autonomous Decision Making
+
+Like the Discord bot's `plan_next_action()`, this skill can autonomously decide:
+
+```
+SHOULD I:
+- Plan before executing? → YES if complex
+- Ask questions? → YES if unclear
+- Use Superpowers? → YES if writing code
+- Create tests? → YES if no tests exist
+- Document? → YES if complex logic
+```
+
+### Context-Aware Adaptation
+
+```
+IF codebase has tests:
+  → Write tests first (TDD)
+
+IF codebase is TypeScript:
+  → Use strict typing
+  → Consider interfaces
+
+IF codebase is Python:
+  → Follow PEP 8
+  → Use type hints
+
+IF user is beginner:
+  → Explain each step
+  → Provide educational context
+
+IF user is expert:
+  → Be concise
+  → Focus on results
+```
+
+### Confidence Scoring
+
+Rate confidence in plans (like the Discord bot):
+
+```
+CONFIDENCE 0.9-1.0: Very confident
+  → Proceed immediately
+  → Minimal validation needed
+
+CONFIDENCE 0.6-0.9: Confident
+  → Proceed with caution
+  → Verify assumptions
+
+CONFIDENCE 0.3-0.6: Somewhat confident
+  → Ask clarifying questions
+  → Get user confirmation
+
+CONFIDENCE 0.0-0.3: Low confidence
+  → MUST ask questions
+  → Present multiple options
+  → Get explicit approval
+```
+
+## WORKFLOW INTEGRATION
+
+This skill enhances other skills:
+
+```
+WITH SUPERPOWERS:
+  → Activates appropriate Superpowers workflows
+  → Adds cognitive context to planning
+  → Adapts to task complexity
+
+WITH UI/UX PRO MAX:
+  → Suggests design skill for UI tasks
+  → Provides user experience context
+  → Balances aesthetics vs functionality
+
+WITH ALWAYS-USE-SUPERPOWERS:
+  → Coordinates automatic skill activation
+  → Prevents over-engineering simple tasks
+  → Ensures systematic approach for complex ones
+```
+
+## BEST PRACTICES
+
+1. **Match complexity to approach**
+   - Simple tasks → Just do it
+   - Complex tasks → Plan systematically
+
+2. **Ask questions when uncertain**
+   - Don't assume requirements
+   - Validate direction before proceeding
+
+3. **Use appropriate tools**
+   - Superpowers for code
+   - UI/UX Pro Max for design
+   - Bash for operations
+   - Task tool for exploration
+
+4. **Adapt to user expertise**
+   - Beginners need explanation
+   - Experts need efficiency
+
+5. **Think autonomous but verify**
+   - Make intelligent decisions
+   - Get approval for major changes
+
+## OUTPUT FORMAT
+
+When this skill activates, output:
+
+```markdown
+## 🧠 Cognitive Planner Analysis
+
+**Task Type**: [classification]
+**Complexity**: [assessment]
+**Interest Level**: [0.0-1.0]
+**Recommended Approach**: [strategy]
+
+**Context**:
+- [relevant observations]
+- [available skills]
+- [constraints]
+
+**Confidence**: [0.0-1.0]
+
+**Action Plan**:
+1. [step 1]
+2. [step 2]
+...
+
+**Activating**: [relevant skills]
+```
+
+---
+
+This skill provides autonomous, context-aware planning that enhances every Claude Code session with intelligent decision making.