Claude Code Plugins

Community-maintained marketplace

Feedback

request-analyzer

@alirezarezvani/claude-cto-team
32
0

Analyze incoming user requests to detect intent, request type (design/validate/debug/document), complexity level, and identify vague requirements or buzzwords that need clarification. Use when cto-orchestrator receives new requests that need classification before routing to specialist agents.

Install Skill

1Download skill
2Enable skills in Claude

Open claude.ai/settings/capabilities and find the "Skills" section

3Upload to Claude

Click "Upload skill" and select the downloaded ZIP file

Note: Please verify skill by going through its instructions before using it.

SKILL.md

name request-analyzer
description Analyze incoming user requests to detect intent, request type (design/validate/debug/document), complexity level, and identify vague requirements or buzzwords that need clarification. Use when cto-orchestrator receives new requests that need classification before routing to specialist agents.

Request Analyzer

Classifies incoming requests to enable intelligent routing and identify clarification needs before delegating to specialist agents.

When to Use

  • When receiving a new user request that needs classification
  • When determining which specialist agent should handle a request
  • When identifying if requirements are too vague to proceed
  • When detecting buzzwords that need to be challenged

Analysis Framework

Step 1: Detect Intent

Classify the primary intent:

Intent Indicators Route
Strategic "roadmap", "strategy", "plan", "prioritize", "decide" May need validation
Implementation "build", "create", "implement", "design", "architect" Design work
Debugging "fix", "broken", "error", "slow", "not working" Debug/investigate
Documentation "document", "explain", "describe", "write docs" Documentation

Step 2: Classify Request Type

Type Key Phrases Primary Agent
Design "How should I build...", "What architecture...", "Design a system..." cto-architect
Validate "Is this plan solid?", "Thoughts on...", "Review my roadmap..." strategic-cto-mentor
Debug "Why is X slow?", "Fix this error...", "Troubleshoot..." debug-helper
Document "Write documentation for...", "Explain how..." docs-writer
Review "Review this code...", "Check for issues..." code-reviewer

Step 3: Assess Complexity

Complexity Characteristics Execution Pattern
Single Clear scope, one domain, obvious routing Direct to one agent
Sequential Multiple phases, depends on previous output Agent chain
Parallel Independent domains, can run simultaneously Multiple agents in parallel

Step 4: Identify Vague Terms

Scan for buzzwords that require clarification. See buzzword-dictionary.md for the complete list.

Common red flags:

  • "AI-powered" - What specific AI capability?
  • "scale" - What numbers? From what to what?
  • "fast" / "soon" - What timeline exactly?
  • "simple" - Simple for whom? What constraints?
  • "modern" - What specific technologies?

Step 5: Detect Missing Context

Check for required context based on request type:

For Design Requests:

  • Expected user/traffic scale
  • Budget constraints
  • Timeline requirements
  • Team size and expertise
  • Existing infrastructure

For Validation Requests:

  • Current state or existing plan
  • Business goals and constraints
  • Timeline and resources
  • Success criteria

Output Format

Provide analysis in this structure:

## Request Analysis

**Intent**: [strategic | implementation | debugging | documentation]
**Type**: [design | validate | debug | document | review]
**Complexity**: [single | sequential | parallel]

### Vague Terms Detected
- "[term]" - needs clarification: [what to ask]

### Missing Context
- [missing information item]

### Suggested Routing
**Primary Agent**: [agent name]
**Rationale**: [why this agent]

### Clarification Needed
[yes/no] - [brief explanation]

### Recommended Next Step
[what to do next - clarify or delegate]

Examples

Example 1: Vague Request

User: "I want to add AI capabilities to my app"

Analysis:

  • Intent: Implementation
  • Type: Design
  • Complexity: Unknown (needs clarification)
  • Vague Terms: "AI capabilities" - What specific problem are we solving?
  • Missing Context: Scale, budget, timeline, team, existing stack
  • Clarification Needed: Yes
  • Next Step: Use clarification-protocol before routing

Example 2: Clear Design Request

User: "Design a real-time notification system for 100K users, using our existing PostgreSQL database and Node.js backend"

Analysis:

  • Intent: Implementation
  • Type: Design
  • Complexity: Single
  • Vague Terms: None
  • Missing Context: Timeline, budget (nice to have but not blocking)
  • Suggested Routing: cto-architect
  • Clarification Needed: No (can proceed with optional clarification)

Example 3: Validation Request

User: "Here's my Q2 roadmap - migrate to microservices, add real-time features, and launch mobile app. Thoughts?"

Analysis:

  • Intent: Strategic
  • Type: Validate
  • Complexity: Single
  • Vague Terms: None
  • Missing Context: Team size, current architecture state
  • Suggested Routing: strategic-cto-mentor
  • Clarification Needed: Mild (some context helpful but not blocking)

References