request-analyzer

What this skill does

# Request Analyzer

This skill proactively analyzes user requests to determine the task type, assess prompt quality, and intelligently recommend which other skills should be activated to best serve the user's needs.

## Purpose

Act as an intelligent coordinator that:
1. Analyzes every user request systematically
2. Assesses prompt quality (clarity, specificity, completeness)
3. Identifies the task type and appropriate workflow
4. Recommends activating specific skills when beneficial
5. Ensures users get the best possible assistance

## When to Use This Skill

**This skill should activate for EVERY user request** at the start of conversations to ensure optimal workflow orchestration.

Specifically activate when:
- A new conversation begins
- User submits a new request or question
- User asks for help with a task
- Any coding, design, or technical request is made
- User's intent needs clarification

## Core Analysis Process

### Step 1: Quick Assessment

Immediately evaluate the request on three dimensions:

**Clarity (0-100%)**:
- Is the request unambiguous?
- Are terms clearly defined?
- Is there only one reasonable interpretation?

**Specificity (0-100%)**:
- Is sufficient context provided?
- Are technical requirements specified?
- Is the scope well-defined?

**Completeness (0-100%)**:
- Is all necessary information present?
- Are success criteria defined?
- Are constraints mentioned?

### Step 2: Task Type Identification

Classify the request into one of these categories:

1. **Code Implementation** - Creating new code
2. **Debugging/Fixing** - Resolving bugs or errors
3. **Analysis/Review** - Examining code or systems
4. **Design Implementation** - Building UI from designs
5. **Refactoring** - Improving existing code
6. **Explanation/Learning** - Understanding concepts
7. **General Question** - Non-technical queries

Reference `references/skill-activation-guide.md` for detailed classification criteria.

### Step 3: Skill Recommendation

Based on assessment and task type, determine which skills would be beneficial:

**Consider prompt-optimizer if**:
- Clarity score < 60%
- Specificity score < 60%
- Completeness score < 60%
- Overall quality < 70%
- Critical information missing
- Multiple interpretations possible

**Consider ui-analyzer if**:
- User mentions: screenshot, design, mockup, Figma, image
- User provides or references an image file
- Request includes "implement this design"
- Task involves analyzing UI layout

**Consider react-component-generator if**:
- User requests creating React component
- Mentions: component, form, button, modal, card, list
- After ui-analyzer identifies components to build
- Clear component requirements are present

### Step 4: Decision and Action

Make one of these decisions:

**Option A: Recommend Optimization**
If prompt quality is low, explicitly suggest using prompt-optimizer:
```
"I notice your request could benefit from more clarity. Let me activate the
prompt-optimizer skill to help structure a more specific request."
```

**Option B: Recommend Specific Skill**
If request is clear but matches a skill's domain:
```
"This looks like a UI design implementation task. I'll use the ui-analyzer
skill to systematically analyze the design and generate the code."
```

**Option C: Proceed Directly**
If request is clear, complete, and doesn't need specialized skills:
```
"Your request is clear. I'll proceed with [task description]."
```

**Option D: Ask for Clarification**
If critical information is missing and cannot be assumed:
```
"To help you effectively, I need to know: [specific questions]"
```

## Analysis Workflow

### For Every Request

1. **Read the request carefully**
2. **Score on three dimensions** (Clarity, Specificity, Completeness)
3. **Identify task type** using the classification system
4. **Check skill activation criteria** from the reference guide
5. **Make recommendation** (optimize, activate skill, proceed, or clarify)
6. **Take action** based on the decision

### Detailed Steps

**Step 1: Initial Read**
- Understand user intent
- Note any attachments or references
- Consider conversational context

**Step 2: Quality Scoring**

Clarity Check:
- [ ] No vague language ("thing", "something", "stuff")?
- [ ] All terms defined?
- [ ] Single clear interpretation?
- [ ] Action verb present?

Specificity Check:
- [ ] Context provided?
- [ ] Technical specs mentioned (for code)?
- [ ] Scope defined?
- [ ] Examples given (if helpful)?

Completeness Check:
- [ ] All inputs provided?
- [ ] Success criteria stated?
- [ ] Constraints mentioned?
- [ ] Edge cases considered?

**Step 3: Task Classification**

Match against patterns in `references/skill-activation-guide.md`:
- Code Implementation patterns
- Debugging patterns
- Analysis patterns
- Design Implementation patterns
- Refactoring patterns

**Step 4: Skill Matching**

For each available skill, check if activation criteria are met:

```
prompt-optimizer:
- Quality score < 70%? → Consider
- Missing critical info? → Consider
- Vague language present? → Consider
- Multiple interpretations? → Consider

ui-analyzer:
- Screenshot/design mentioned? → Activate
- Image provided? → Activate
- "Implement design" request? → Activate

react-component-generator:
- React component requested? → Consider
- After prompt optimization? → Consider
- Clear component spec? → Activate
```

**Step 5: Recommendation**

Based on analysis, formulate recommendation:
- Which skill(s) to activate
- Why they're beneficial
- What to expect from them

**Step 6: Execution**

Either:
- Explicitly note the skill activation (for transparency)
- Seamlessly integrate skill usage
- Ask for user confirmation if uncertain

## Output Formats

### Format 1: Optimization Recommended (Low Quality Prompt)

```markdown
## Request Analysis

I've analyzed your request and noticed it could benefit from more specificity.

**Current Request**: [User's request]

**Observations**:
- Missing: [what's missing]
- Unclear: [what's ambiguous]
- Would help: [what would improve it]

**Recommendation**: Let me use the prompt-optimizer skill to help structure
a clearer, more actionable request.

[Then activate prompt-optimizer]
```

### Format 2: Skill Recommended (Good Prompt, Specific Domain)

```markdown
## Request Analysis

Your request is clear and matches our ui-analyzer skill's capabilities.

**Task Type**: Design Implementation
**Recommended Approach**:
1. Use ui-analyzer to examine the screenshot
2. Extract design tokens and components
3. Generate React code with Tailwind CSS

Proceeding with UI analysis...

[Then activate ui-analyzer]
```

### Format 3: Direct Execution (High Quality, No Special Skill Needed)

```markdown
## Request Analysis

Your request is clear and complete. I'll proceed with creating the TypeScript
function with input validation as specified.

[Proceed with implementation]
```

### Format 4: Clarification Needed

```markdown
## Request Analysis

To help you effectively, I need some additional information:

1. [Question 1]
2. [Question 2]
3. [Question 3]

Once I have these details, I can [what you'll do].
```

## Integration with Other Skills

### With prompt-optimizer

**When to Delegate**:
- Quality scores indicate issues
- Request is vague or incomplete
- Multiple interpretations exist
- Critical information missing

**How**:
1. Identify the quality issues
2. Explain why optimization would help
3. Mention activating prompt-optimizer
4. Let prompt-optimizer take over

**Example Flow**:
```
User: "Make a form"
↓
request-analyzer: Detects low specificity
↓
request-analyzer: "This request needs more details. Activating prompt-optimizer..."
↓
prompt-optimizer: Analyzes and provides optimized version
↓
User: Confirms optimized version
↓
react-component-generator: Creates the well-specified form
```

### With ui-analyzer

**When to Delegate**:
- Screenshot or design mentioned
- Image file provided
- Design implementation requested

**How**:
1. Confirm it's a design implementation task
2. V