user-intent-parser
Parse user requirements into structured format with explicit assumptions, constraints, and acceptance criteria. Use when initial requirements are ambiguous or informal.
When & Why to Use This Skill
The User Intent Parser is a specialized Claude skill designed to bridge the gap between informal communication and technical execution. It systematically transforms vague user requests into professional, structured requirement documents by extracting explicit actions, identifying implicit assumptions, and flagging ambiguities. This skill ensures project alignment, reduces scope creep, and provides a solid foundation for development by generating clear acceptance criteria and confidence-rated specifications.
Use Cases
- Requirement Gathering: Converting conversational or informal feature requests from non-technical stakeholders into structured technical specifications.
- Scope Refinement: Analyzing vague project descriptions to identify hidden assumptions and missing constraints before development begins.
- Bug Report Analysis: Transforming subjective performance complaints (e.g., 'the site is slow') into objective technical requirements and target metrics.
- Standardized Documentation: Generating consistent 'Parsed Intent' documents for every new session to maintain a clear audit trail of project requirements and acceptance criteria.
| name | user-intent-parser |
|---|---|
| description | Parse user requirements into structured format with explicit |
User Intent Parser Skill
Purpose
Convert informal user requests into structured requirement format.
When to Use
- User provides vague or informal request
- Requirements are conversational rather than structured
- Non-technical user is specifying features
- Need to formalize verbal requirements
Parsing Process
Step 1: Extract Explicit Statements
Identify what user directly stated:
- Actions (verbs): create, update, delete, show, send, etc.
- Objects (nouns): user, product, order, notification, etc.
- Conditions (when/if): triggers, prerequisites
- Outcomes (so that): expected results
Step 2: Identify Implicit Requirements
What's assumed but not stated:
- Authentication required?
- Error handling expectations
- Performance expectations
- Platform/device support
- Data validation needs
Step 3: Flag Ambiguities
Mark unclear items:
- Vague terms ("fast", "good", "easy", "simple")
- Missing specifics (quantities, limits)
- Unclear scope (boundaries)
- Undefined actors (who does what)
Step 4: Generate Structured Format
Use templates/parsed-intent.md
Output Format
Parsed Intent Document
Save to: docs/specs/parsed-intent-{session}.md
The template captures:
- Original user statement
- Extracted functional requirements
- Extracted non-functional requirements
- Assumptions made (with rationale)
- Ambiguities requiring clarification
- Draft acceptance criteria
Confidence Levels
Assign confidence to each extracted requirement:
| Level | Meaning | Action |
|---|---|---|
| High | Directly stated by user | Proceed |
| Medium | Strongly implied | Confirm |
| Low | Inferred/assumed | Must clarify |
Common Patterns
Feature Requests
User: "I need users to be able to export their data"
Parsed:
- Action: export
- Object: user data
- Actor: users (authenticated)
- Implicit: format unspecified, permissions assumed
- Ambiguity: which data? what format?
Bug Reports as Features
User: "The search is too slow"
Parsed:
- Action: improve search performance
- Implicit: current performance is unacceptable
- Ambiguity: how slow? target speed?
Vague Requests
User: "Make the dashboard better"
Parsed:
- Action: improve dashboard
- Ambiguity: which aspects? visual? functional? performance?
- Confidence: Low (requires extensive clarification)
Integration Points
- Research findings inform implicit requirements
- Generated ambiguities feed into question generation
- Structured output becomes input for requirements validation
Storage Location
Save to: docs/specs/parsed-intent-{session}.md
Quality Checklist
Before completing parsing:
- All explicit actions identified
- All objects/entities named
- Implicit requirements documented
- Ambiguities clearly flagged
- Confidence levels assigned
- Draft acceptance criteria created