---
name: always-use-superpowers
description: "CRITICAL: Always check cognitive skills and applicable skills before ANY action. Triggers automatically for all tasks."
priority: 9999
autoTrigger: true
---

# ALWAYS USE SKILLS - Cognitive Enhancement System

<CRITICAL>
THIS IS THE HIGHEST PRIORITY SKILL. YOU MUST CHECK AVAILABLE SKILLS BEFORE **EVERY** SINGLE ACTION, RESPONSE, OR TASK.

THERE ARE NO EXCEPTIONS. EVER.

THIS SKILL TRIGGERS BEFORE EVERYTHING ELSE - NO MATTER WHAT THE USER ASKS.
</CRITICAL>

## What This Means

Before you do ANYTHING - including:
- Answering questions
- Writing code
- Reading files
- Running commands
- Explaining concepts
- Making suggestions
- Clarifying requirements
- ANY action at all

You MUST:
1. **First**, review all available skills to determine which apply
2. **Then**, invoke applicable skills using the Skill tool BEFORE responding
3. **Only after** following all applicable skills, then respond to the user

## Available Skills

### Core Skills (Always Check These):

#### 1. cognitive-planner
**When to use:** Planning, strategy, complex task breakdown, implementation roadmaps
- Use before: Implementing features, architectural decisions, multi-step tasks
- Priority: HIGH for any planning work

#### 2. cognitive-context
**When to use:** Understanding context, gathering information, analysis
- Use before: Any task requiring context, code analysis, understanding systems
- Priority: HIGH for understanding requirements

#### 3. cognitive-safety
**When to use:** Security, safety, error handling, edge cases
- Use before: Security decisions, error handling, validation, user input
- Priority: CRITICAL for any security/safety concerns

#### 4. ui-ux-pro-max
**When to use:** UI/UX design, frontend work, visual improvements
- Use before: Any design work, HTML/CSS, component creation, layouts
- Priority: HIGH for any UI/UX work

#### 5. codebase-indexer (ALWAYS ACTIVE)
**When to use:** EVERY TASK involving code navigation, file searches, codebase understanding
- **ALWAYS RUN THIS FIRST** before any code-related task
- Use for: Finding files, understanding code structure, semantic search, 40-60% token reduction
- Priority: CRITICAL - Runs automatically on ALL code tasks
- Benefit: Drastically reduces token usage and provides intelligent code context

### Auto-Trigger Conditions:

The `always-use-superpowers` skill should automatically trigger when:
- User sends ANY message
- ANY task is requested
- ANY code is being written
- ANY changes are being made

## Decision Process

```
User sends message
    ↓
Check: Is this code-related work?
    ↓ YES → Invoke codebase-indexer (ALWAYS)
    ↓ NO
Check: Is this UI/UX work?
    ↓ YES → Invoke ui-ux-pro-max
    ↓ NO
Check: Is this planning/strategy?
    ↓ YES → Invoke cognitive-planner
    ↓ NO
Check: Is this context/analysis needed?
    ↓ YES → Invoke cognitive-context
    ↓ NO
Check: Any security/safety concerns?
    ↓ YES → Invoke cognitive-safety
    ↓ NO
Proceed with task
```

## Examples

### Example 1: User asks "Fix the blog post design"

**Process:**
1. ✅ This is UI/UX work → Invoke `ui-ux-pro-max`
2. Follow UI/UX guidelines for accessibility, responsive design, visual hierarchy
3. Apply improvements
4. Respond to user

### Example 2: User asks "Implement a feature for X"

**Process:**
1. ✅ This is planning work → Invoke `cognitive-planner`
2. ✅ This may affect UI → Invoke `ui-ux-pro-max`
3. ✅ Need context → Invoke `cognitive-context`
4. Follow skill guidance
5. Implement feature
6. Respond to user

### Example 3: User asks "Update database credentials"

**Process:**
1. ⚠️ Security concern → Invoke `cognitive-safety`
2. Follow security guidelines
3. Make changes safely
4. Respond to user

### Example 4: User asks "What does this code do?"

**Process:**
1. ✅ Need context → Invoke `cognitive-context`
2. Analyze code with context guidance
3. Explain to user

### Example 5: User asks "How do I add a button?"

**Process:**
1. ✅ This is UI/UX work → Invoke `ui-ux-pro-max`
2. Follow design guidelines (accessibility, interactions, styling)
3. Provide guidance with best practices
4. Respond to user

## Red Flags - STOP IMMEDIATELY

If you think ANY of these, you are WRONG:

| Wrong Thought | Reality |
|---------------|----------|
| "This is just a quick question" | Quick questions still need skill checks |
| "I already checked skills once" | Check EVERY time, EVERY message |
| "This doesn't need skills" | EVERYTHING needs skill check first |
| "User just wants a simple answer" | Simple answers come AFTER skill checks |
| "I'll skip it this one time" | NEVER skip. Not once. Not ever. |
| "The skills don't apply here" | Check first, then decide. Don't assume. |
| "This is just clarifying" | Clarification comes AFTER skill checks |
| "I'm just gathering info" | Skills tell you HOW to gather info. Check first. |

## Quick Reference: When to Use Each Skill

| Situation | Skill to Invoke | Priority |
|-----------|----------------|----------|
| UI/UX design, HTML/CSS, visual work | `ui-ux-pro-max` | HIGH |
| Planning, strategy, implementation | `cognitive-planner` | HIGH |
| Understanding code, context, analysis | `cognitive-context` | HIGH |
| Security, validation, error handling | `cognitive-safety` | CRITICAL |
| Any design work | `ui-ux-pro-max` | HIGH |
| Any frontend work | `ui-ux-pro-max` | HIGH |
| Any database changes | `cognitive-safety` | CRITICAL |
| Any user input handling | `cognitive-safety` | CRITICAL |
| Any API endpoints | `cognitive-safety` | CRITICAL |
| Complex multi-step tasks | `cognitive-planner` | HIGH |
| Code analysis/reviews | `cognitive-context` | HIGH |

## How to Invoke Skills

Use the Skill tool with the skill name:
```
Skill: ui-ux-pro-max
Skill: cognitive-planner
Skill: cognitive-context
Skill: cognitive-safety
```

## Special Note: Always-Use Pattern

This skill itself (`always-use-superpowers`) should be treated as a pattern/mindset, not necessarily invoked directly. Instead:

1. **Recognize** that skills should always be checked first
2. **Evaluate** which skills apply to the current task
3. **Invoke** applicable skills before taking action
4. **Follow** skill guidance precisely
5. **Then** respond to user

## Summary

For EVERY single user message:
1. Check which skills apply (ui-ux-pro-max, cognitive-*, etc.)
2. Invoke applicable skills BEFORE doing anything
3. Follow skill instructions exactly
4. Only then respond to user

**THIS HAPPENS FOR EVERY SINGLE MESSAGE. NO EXCEPTIONS.**

---

## Integration Examples

### UI/UX Work Example:
```
User: "Make the button look better"
→ Invoke: ui-ux-pro-max
→ Follow: Design guidelines, accessibility, interactions
→ Result: Professional, accessible button
```

### Planning Example:
```
User: "Implement user authentication"
→ Invoke: cognitive-planner (for implementation plan)
→ Invoke: cognitive-safety (for security)
→ Invoke: ui-ux-pro-max (for login UI)
→ Follow: All skill guidance
→ Result: Secure, planned, well-designed auth system
```

### Debug Example:
```
User: "Why is this code broken?"
→ Invoke: cognitive-context (understand code)
→ Invoke: cognitive-safety (check for security issues)
→ Follow: Analysis and safety guidelines
→ Result: Comprehensive analysis
```

### Quick Question Example:
```
User: "What's the difference between X and Y?"
→ Invoke: cognitive-context (for accurate context)
→ Follow: Context guidance
→ Result: Accurate, contextual answer
```

---

**Remember: When in doubt, check skills first. Always.**
