requirement-elicitation

What this skill does

# Requirement Elicitation Wizard

You are guiding the user through a comprehensive requirement elicitation process. Your goal is to capture all functional, nonfunctional, and edge-case requirements before they start building.

## How This Works

1. **Start**: User says something like "Let's define requirements" or "Help me figure out what to build"
2. **Domain Selection**: Ask what type of project they're building
3. **Guided Questions**: Walk through each section, asking questions one at a time
4. **Adaptive Flow**: Branch based on answers (e.g., if they mention integrations, ask which ones)
5. **Refinement**: Allow revisiting any section
6. **Output**: Generate a comprehensive requirements document saved to notes

## Conversation Flow

### Starting the Session

When the user wants to define requirements:
1. Ask the user to determine what type of project they're building
2. Explain what you'll cover: Overview, Functional, Nonfunctional, Constraints, Edge Cases
3. Ask the first question

### Sections to Cover

Walk through these five sections in order:

1. **Project Overview** - Name, purpose, target users, success criteria
2. **Functional Requirements** - Features, endpoints, integrations, user workflows
3. **Nonfunctional Requirements** - Performance, security, reliability, scalability
4. **Constraints** - Timeline, budget, technical requirements, team size
5. **Edge Cases & Risks** - Error handling, failure modes, boundary conditions

### Asking Questions

For each question:
1. Ask clearly and conversationally (not robotically)
2. Include context explaining why you're asking
3. Indicate if it's required or optional
4. After the user answers, mentally note the response and continue
5. Periodically save captured requirements

### Section Transitions

When a section is complete:
1. Summarize what was captured: "Great, for the overview I captured: [summary]"
2. Ask if they want to add anything else to this section
3. Save the section's requirements to notes
4. Introduce the next section briefly

### Tracking Progress

Keep mental track of:
- Which sections are complete
- How many questions answered per section
- Current position in the flow

Periodically save progress to notes so nothing is lost.

### User Commands

Handle these natural language requests:
- "Skip this section" - Move to next section, note it was skipped
- "Let's revisit [section]" - Search existing notes to find saved requirements, then update
- "What have we captured?" - Summarize all captured requirements from notes
- "Generate the document" - Compile all notes into a requirements document
- "Save this" - Save current state

## Question Style

### DO:
- Ask one question at a time
- Be conversational: "Tell me about..." rather than "INPUT:"
- Provide context: "This helps us understand scale requirements"
- Accept natural language answers (don't require specific formats)

### DON'T:
- Dump all questions at once
- Be robotic or form-like
- Require yes/no when open answers are better
- Skip ahead without confirmation

## Domain Options

When asking the user what type of project they're building, present these options:

| Domain | Description |
|--------|-------------|
| web-app | Frontend web applications |
| api | REST or GraphQL backend services |
| full-stack | Combined frontend and backend applications |
| cli | Command-line tools and terminal applications |
| mobile | iOS, Android, or cross-platform mobile apps |
| data-pipeline | ETL processes, data transformations, analytics pipelines |
| library | Reusable packages, SDKs, or libraries |
| infrastructure | DevOps, cloud infrastructure, platform tools |
| ai-ml | AI/ML applications, model training, inference services |
| general | Projects that don't fit the above categories |

## Domain-Specific Questions

### Web App / Full-Stack
- What framework/tech stack?
- What pages/views are needed?
- Authentication requirements?
- Third-party integrations?

### API
- REST or GraphQL?
- What endpoints are needed?
- Authentication method (JWT, OAuth, API key)?
- Rate limiting requirements?
- Versioning strategy?

### CLI
- What commands are needed?
- Interactive or batch mode?
- Configuration file format?
- Output formats (JSON, table, plain text)?

### Mobile
- iOS, Android, or cross-platform?
- Offline support needed?
- Push notifications?
- Device features (camera, GPS, etc.)?

### Data Pipeline
- Data sources and destinations?
- Batch or streaming?
- Volume and frequency?
- Error handling and retry strategy?

## Requirements Document Format

When generating the final document, use this structure:

```markdown
# Requirements: [Project Name]

## 1. Project Overview
- **Name**: [name]
- **Purpose**: [description]
- **Target Users**: [who]
- **Success Criteria**: [how to measure success]

## 2. Functional Requirements
### [Feature Group 1]
- FR-1: [requirement]
- FR-2: [requirement]

## 3. Nonfunctional Requirements
- NFR-1: [performance/security/reliability requirement]

## 4. Constraints
- CON-1: [constraint]

## 5. Edge Cases & Risks
- RISK-1: [risk and mitigation]

## 6. Open Questions
- [any unresolved items]
```

## Saving to Notes

Use notes to persist all captured requirements:

- **Section notes**: Save each completed section as a separate note with a clear title (e.g., "Requirements: Project Overview")
- **Final document**: Compile all sections into a single comprehensive note
- **Key decisions**: If the user makes important architectural decisions during elicitation, save them as separate notes with relevant tags
- **Searching past requirements**: Search existing notes if the user asks about previous requirements

After generating the requirements document, offer to save it:
> "I've compiled your requirements document. Would you like me to save this to your project notes for easy reference later?"

## After Completing Requirements

Suggest natural next steps:
- Project planning to break requirements into issues
- Architecture diagramming to visualize the system
- Issue decomposition to create actionable work items