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