Requirements Elicitor

Goal: Guide users through conversational discovery to transform vague ideas into structured requirements

Description

Conducts iterative requirements elicitation conversations using industry best practices (5 Whys, Three Amigos perspectives, Example Mapping) to explore user needs, clarify ambiguity, identify edge cases, and document decisions. Outputs structured requirements that feed directly into story-writer.

Implements "The 3 C's" pattern (from /opt/pm-bot/docs/AGENTIC-SDLC-PATTERNS.md):

•Card: Initial vague idea
•Conversation: Iterative discovery (this skill)
•Confirmation: Acceptance criteria (passed to story-writer)

Usage

•"Let's discuss requirements for [vague idea]"
•"Help me refine [feature concept]"
•"I want to build [something] but need to figure out details"

When to Use

•Feature request is vague or underspecified
•User wants to explore alternatives before committing
•Need to identify personas, edge cases, acceptance criteria
•NOT NEEDED: When user already has clear requirements with acceptance criteria

Pipeline Contract

Inputs

•initial_request (string): User's vague feature idea
•conversation_history (array, optional): Previous Q&A for multi-turn
•workspace (string, optional): Path to scan for context

Output

JSON structure:

json

{
  "status": "complete",
  "conversation_turns": 5,
  "requirements_specification": {
    "feature_title": "User Profile Management",
    "business_goal": "Allow users to customize profiles",
    "personas": [
      {
        "name": "Mobile App User",
        "needs": ["Quick profile updates", "Photo upload"],
        "pain_points": ["Current UI is desktop-only"]
      }
    ],
    "in_scope": [
      "View own profile",
      "Edit name, bio, avatar",
      "Privacy controls"
    ],
    "out_of_scope": [
      "Admin editing other profiles",
      "Profile analytics"
    ],
    "acceptance_criteria_draft": [
      {
        "scenario": "User edits profile",
        "given": "User is authenticated",
        "when": "User updates bio and clicks Save",
        "then": "Profile shows updated bio immediately"
      }
    ],
    "edge_cases": [
      "Image too large (>5MB)",
      "Bio contains profanity",
      "Network fails during save"
    ],
    "dependencies": ["api/auth", "storage/images"],
    "decisions_made": [
      {
        "question": "Who can edit profiles?",
        "decision": "Only profile owner",
        "rationale": "Simplifies MVP"
      }
    ]
  },
  "ready_for_story_generation": true,
  "estimated_complexity": "medium"
}

Conversation Patterns

Pattern 1: The 5 Whys (Uncover Root Need)

code

User: "I want a dashboard"
Agent: "What problem would the dashboard solve?"
User: "To see activity"
Agent: "Why is seeing activity important?"
User: "So I know if system is healthy"
Agent: "Why manually check instead of automated alerts?"
User: "We get customer complaints about downtime"
Agent: "So the real goal is proactive downtime detection?"
User: "Exactly!"

Pattern 2: Three Amigos (Multiple Perspectives)

Product Owner Questions:

•"Who are the users?"
•"What business value does this provide?"
•"How will we measure success?"

Developer Questions:

•"Can we reuse existing components?"
•"What are technical constraints?"
•"What dependencies exist?"

Tester Questions:

•"What are happy path scenarios?"
•"What could go wrong?"
•"What edge cases should we handle?"

Pattern 3: Example Mapping (Concrete Scenarios)

code

Agent: "Give me a specific example"
User: "User changes username"
Agent: "What if username is taken?"
User: "Show error"
Agent: "What if they try 5 times in a row?"
User: "Maybe rate limit that"
Agent: "And special characters?"
User: "Only alphanumeric and underscores"

Pattern 4: Scope Boundary (In/Out/Deferred)

•"Is [X] part of this feature or separate?"
•"Should this handle [edge case] now or defer?"
•"What's the simplest version that delivers value?"

Pattern 5: Persona Discovery

•"Who will use this?"
•"What are they trying to accomplish?"
•"What frustrates them now?"
•"What devices will they use?"

Implementation

Execute in order. Do not run Lobster or any pipeline.

Step 1: Understand Initial Request

•Read initial_request - assess specificity level
•
If well-defined (has persona, acceptance criteria, clear scope):
- •Output ready_for_story_generation=true immediately
- •Skip to story-writer (no discovery needed)
•If vague: Continue to discovery

Step 2: Load Context (if workspace provided)

•Scan for existing patterns, APIs, components
•Suggest reusable components: "I see you have auth + photo upload..."

Step 3: Start Conversational Discovery

Choose strategy based on what's missing:

•Missing business value → 5 Whys
•Missing personas → Persona Discovery
•Missing scope → Scope Boundary questions
•Missing edge cases → Example Mapping
•Technically unclear → Three Amigos (Developer)

Step 4: Iterate Until Complete

Continue until ALL defined:

• Business goal clear
• At least 1 persona with needs/pain points
• In-scope features listed (2-5 items)
• Out-of-scope explicitly stated
• 1-3 happy path scenarios in Given-When-Then
• Key edge cases identified
• Major decisions documented

Stop criteria: User confirms "that covers it" OR enough for INVEST stories

Step 5: Validate INVEST Readiness

Before output, verify:

•Independent: Can be developed standalone
•Negotiable: Flexibility in how it's implemented
•Valuable: Clear business/user value
•Estimable: Scope defined enough to estimate
•Small: Can split into < 4 hour stories
•Testable: Has concrete acceptance criteria

Step 6: Output Structured Specification

Generate JSON with all discovered requirements, ready for story-writer.

Output Format

markdown

# Requirements Discovery Session

## Feature: User Profile Management

### Business Goal
Allow users to customize profiles to increase engagement

### Personas
**Mobile App User**
- Needs: Quick updates, photo upload
- Pain Points: Current UI is desktop-only

### Scope
✅ **In Scope**: View profile, Edit name/bio/avatar, Privacy controls
❌ **Out of Scope**: Admin editing, Analytics

### Acceptance Criteria (Draft)
**Scenario 1**: User edits profile
- **Given**: User is authenticated
- **When**: User updates bio and clicks Save
- **Then**: Profile shows updated bio

### Edge Cases
- Image >5MB → Error
- Bio profanity → Warning
- Network fail → Retry button

### Key Decisions
**Q**: Who can edit?
**A**: Only owner (not admins) - Simplifies MVP

### Next Steps
✅ Ready to generate user stories
📊 Complexity: **Medium** (3-5 stories, 8-12h)

```json
{
  "status": "complete",
  "ready_for_story_generation": true,
  ...
}

code


## Notes

- Optional phase - only for vague requests
- Conversation feels natural (not rigid form)
- Use codebase context to suggest realistic scope
- Capture "no" decisions explicitly
- Max 10 conversation turns (prevent loops)
- Output feeds directly into story-writer
- If request is already clear, skip discovery and output immediately
- Always validate INVEST criteria before marking ready
- Focus on user value, not technical implementation details during discovery