request-analyzer（请求分析器）

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)

## 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)

## 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)

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

## 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. Verify image is available or referenced
3. Explain ui-analyzer will handle it
4. Let ui-analyzer take over

Example Flow:

User: "Build this UI [screenshot attached]"
↓
request-analyzer: Detects design implementation task
↓
request-analyzer: "I'll use ui-analyzer to examine your design..."
↓
ui-analyzer: Analyzes screenshot and generates code

With react-component-generator

When to Delegate:

• React component requested
• Specifications are clear
• No design screenshot (verbal description)

How:

1. Confirm component requirements are clear
2. If not clear, use prompt-optimizer first
3. Once clear, mention using react-component-generator
4. Let it handle component creation

Example Flow:

User: "Create a React login form with email/password, validation, TypeScript"
↓
request-analyzer: Detects high-quality component request
↓
request-analyzer: "Clear component spec. Using react-component-generator..."
↓
react-component-generator: Creates the component

Decision Matrix

Special Considerations

Conversational Context

If this is a follow-up in an ongoing conversation:

• Previous messages may provide missing context
• Don't over-analyze brief follow-ups
• "Now add validation" is fine after "Create a form"
• Consider the full conversation history

User Experience

Balance thoroughness with efficiency:

• Don't over-process simple, clear requests
• Avoid creating friction for experienced users
• Be helpful but not pedantic
• Transparent about why skills are beneficial

Confidence Levels

High Confidence (>90%) - Act decisively:

• Prompt clearly matches skill domain
• Quality issues are obvious
• Recommendation is unambiguous

Medium Confidence (60-90%) - Suggest and explain:

• Partial match to skill domain
• Some quality concerns
• Explain the benefit of using a skill

Low Confidence (<60%) - Ask or proceed cautiously:

• Unclear match
• No obvious quality issues
• Might not need special skills

Reference Usage

Consult references/skill-activation-guide.md for:

• Available Skills - Full list with activation criteria
• Request Type Classification - Detailed patterns
• Decision Tree - Visual workflow guide
• Multi-Skill Scenarios - Complex activation patterns
• Activation Confidence Levels - When to activate
• Common Patterns - Recognize typical requests
• Edge Cases - Handle special situations

Examples

Example 1: Vague Request

User: "Fix my code"

Analysis:
- Clarity: 20% (what code? what's wrong?)
- Specificity: 10% (no file, no error, no context)
- Completeness: 15% (no reproduction steps, no expected behavior)
- Overall: 15% → Very Low

Decision: Activate prompt-optimizer

Output:
"I notice your request needs more details to be actionable. Let me help
structure it using the prompt-optimizer skill.

Missing information:
- Which file or code section?
- What's the current behavior?
- What error messages appear?
- What should happen instead?

[Activating prompt-optimizer...]"

Example 2: UI Design Request

User: "Implement this login page design [screenshot]"

Analysis:
- Clarity: 85% (clear intent)
- Specificity: 80% (has design, mentions login page)
- Completeness: 75% (might need tech stack clarification)
- Task Type: Design Implementation
- Has Screenshot: Yes

Decision: Activate ui-analyzer (might clarify tech stack within workflow)

Output:
"I'll analyze your login page design and generate the React components.

Using the ui-analyzer skill to:
1. Examine the layout and components
2. Extract design tokens (colors, spacing, typography)
3. Generate React + TypeScript + Tailwind code

[Activating ui-analyzer...]"

Example 3: Clear Component Request

User: "Create a React Button component with TypeScript, supporting primary/
secondary/danger variants, sm/md/lg sizes, and Tailwind CSS styling"

Analysis:
- Clarity: 95% (very clear)
- Specificity: 95% (all tech specs present)
- Completeness: 90% (comprehensive requirements)
- Task Type: Code Implementation (React component)
- Overall: 93% → Excellent

Decision: Activate react-component-generator directly

Output:
"Excellent! Your component requirements are clear and complete. I'll use the
react-component-generator skill to create this button component.

[Activating react-component-generator...]"

Example 4: General Question

User: "What's the difference between useState and useReducer in React?"

Analysis:
- Clarity: 100% (perfectly clear)
- Task Type: Explanation/Learning
- No coding task
- No design implementation

Decision: Proceed directly (no special skill needed)

Output:
"Great question! Let me explain the differences between useState and useReducer..."

[Provide explanation directly - no skill activation needed]

Best Practices

1. Be proactive but not intrusive - Help without creating friction
2. Explain the value - Tell users why a skill will help
3. Stay transparent - Mention which skills you're using and why
4. Respect user time - Don't over-analyze trivial requests
5. Learn from context - Consider conversation history
6. Balance automation with judgment - Skills are tools, not rules
7. Prioritize user success - The goal is better outcomes, not perfect process

Important Notes

• This skill is a coordinator, not a blocker
• High-quality prompts should flow smoothly without intervention
• Skills should enhance, not hinder, the user experience
• When in doubt, ask the user rather than making assumptions
• Transparency builds trust - explain your reasoning
• The ultimate goal is helping users succeed with their tasks