SuperCharged-Claude-Code-Upgrade/skills/cognitive-planner/SKILL.md

name, description, version, author

name	description	version	author
cognitive-planner	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.	1.0.0	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:

## 🎯 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:

## 🧠 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.