Business Requirements Interview

This skill guides you through a structured interview process to gather comprehensive business requirements for a software project.

Interview Process

Rules

One question at a time - Never ask multiple questions in a single turn
Provide options - Each question includes 2-5 recommended options plus free-form input
Track progress - All Q&A pairs are immediately appended to business-interview.jsonl
Resume capability - If JSONL exists, continue from last question
Structured output - Generate business-requirements.yaml upon completion

Interview Categories

The interview covers these areas in order:

Problem Definition & Scope
- What problem are you solving?
- What's the core value proposition?
- What's in scope vs out of scope?
User Personas & Use Cases
- Who are the primary users?
- What are their goals?
- What are their pain points?
Success Criteria & Metrics
- How will you measure success?
- What are the key outcomes?
- What metrics matter?
Constraints & Dependencies
- Technical constraints?
- Business constraints?
- Timeline constraints?
- External dependencies?
Priority & Timeline
- What's the MVP scope?
- What's the timeline?
- What's the priority order?

Question Format

Each question follows this structure:

## [Category Name]

**Question:** [Clear, specific question]

**Options:**
1. [Option 1] (Recommended) - [Brief description of this approach]
2. [Option 2] - [Brief description]
3. [Option 3] - [Brief description]
4. Type your own answer

Example Questions

Problem Definition

## Problem Definition

**Question:** What is the primary problem your project aims to solve?

**Options:**
1. Automate manual workflow (Recommended) - Replace time-consuming manual processes with automated workflows
2. Improve existing solution - Enhance or replace current tooling that's inadequate
3. New capability - Build something entirely new that doesn't exist yet
4. Type your own answer

User Personas

## User Personas

**Question:** Who are your primary target users?

**Options:**
1. Individual developers (Recommended) - Solo developers working on personal or small projects
2. Development teams - Small to medium teams collaborating on shared codebases
3. Enterprise organizations - Large teams with complex workflows and compliance needs
4. End users (non-technical) - Users who interact with the product but don't write code
5. Type your own answer

Scope Definition

## Scope Definition

**Question:** What is the initial scope for this project?

**Options:**
1. MVP/Proof of concept (Recommended) - Minimal viable product to validate core assumptions
2. Full-featured release - Complete implementation of all planned features
3. Iterative enhancement - Start with core features, expand over time
4. Type your own answer

JSONL Format

Track all questions and answers in business-interview.jsonl:

{"id":1,"category":"Problem Definition","question":"What is the primary problem your project aims to solve?","answer":"Automate manual workflow - Replace time-consuming manual processes with automated workflows","timestamp":"2025-01-27T10:00:00Z"}
{"id":2,"category":"User Personas","question":"Who are your primary target users?","answer":"Individual developers - Solo developers working on personal or small projects","timestamp":"2025-01-27T10:05:00Z"}

Output Format

Generate business-requirements.yaml with this structure:

project: [project-name]
version: "1.0.0"
generated: [timestamp]

overview:
  problem: |
    [Problem description]
  value_proposition: |
    [Core value being delivered]
  scope:
    in_scope:
      - [Item 1]
      - [Item 2]
    out_of_scope:
      - [Item 1]
      - [Item 2]

personas:
  - name: [Persona Name]
    description: [Who they are]
    goals:
      - [Goal 1]
      - [Goal 2]
    pain_points:
      - [Pain point 1]
      - [Pain point 2]

use_cases:
  - name: [Use Case Name]
    actor: [Who performs it]
    description: [What they do]
    outcome: [What they achieve]

functional_requirements:
  - id: FR-1
    category: [Category]
    description: [Requirement description]
    priority: [high/medium/low]
    rationale: [Why this is needed]

non_functional_requirements:
  performance:
    - [Performance requirement 1]
  security:
    - [Security requirement 1]
  usability:
    - [Usability requirement 1]
  reliability:
    - [Reliability requirement 1]

success_criteria:
  - criterion: [Success criterion]
    metric: [How to measure]
    target: [Target value]

constraints:
  technical:
    - [Technical constraint 1]
  business:
    - [Business constraint 1]
  timeline:
    - [Timeline constraint 1]
  budget:
    - [Budget constraint 1]

dependencies:
  internal:
    - [Internal dependency 1]
  external:
    - [External dependency 1]

timeline:
  phase: [Phase name]
  duration: [Duration]
  milestones:
    - [Milestone 1]
    - [Milestone 2]

assumptions:
  - [Assumption 1]
  - [Assumption 2]

risks:
  - risk: [Risk description]
    probability: [high/medium/low]
    impact: [high/medium/low]
    mitigation: [Mitigation strategy]

Usage

To start a new interview:

/business-requirements-interview

To resume an existing interview (if business-interview.jsonl exists):

/business-requirements-interview

The skill will automatically:

Check for existing business-interview.jsonl
Resume from the last question if found
Continue asking questions until complete
Generate business-requirements.yaml when finished

Best Practices

Be specific - Provide detailed answers when using free-form input
Think broadly - Consider edge cases and future needs
Prioritize ruthlessly - Not everything can be in MVP
Document assumptions - Make implicit assumptions explicit
Consider constraints - Be realistic about technical and business limitations

Review & Gap Analysis

After generating business-requirements.yaml, automatically perform a gap analysis:

Completeness Check

Overview Section:

Problem statement is clear and specific
Value proposition explains the "why"
Scope clearly defines in/out of scope items
Scope is realistic for the timeline

Personas:

All user types are represented
Each persona has clear goals
Pain points are specific, not generic
Personas are distinct (not overlapping)

Requirements:

Functional requirements are testable
Priority is assigned to each requirement
Rationale explains why each requirement exists
No duplicate or conflicting requirements

Non-Functional Requirements:

Performance targets are measurable
Security requirements address key risks
Usability requirements are specific
Reliability requirements are realistic

Success Criteria:

Each criterion has a metric
Targets are achievable and measurable
Criteria align with business goals

Constraints:

Technical constraints are realistic
Business constraints are acknowledged
Timeline is feasible
Budget constraints are explicit

Dependencies:

Internal dependencies identified
External dependencies documented
Critical path dependencies noted

Consistency Check

No contradictions between requirements
Priorities align with scope
Timeline aligns with requirements complexity
Success criteria align with scope

Gap Identification

Common Gaps to Check:

Missing edge cases in requirements
Unstated assumptions about users
Implicit constraints not documented
Missing error handling scenarios
Unclear success/failure criteria
Missing integration points
Undocumented business rules

Review Output

Generate a gap analysis report with:

gap_analysis:
  completeness_score: [1-10]
  consistency_score: [1-10]

  gaps_found:
    - category: [category]
      issue: [description]
      severity: [high/medium/low]
      recommendation: [how to address]

  strong_areas:
    - [what's well-defined]

  suggestions:
    - [improvement suggestions]

  ready_for_next_phase: [yes/no/with-modifications]

If critical gaps found (severity: high), ask:

"I've identified some gaps in the business requirements. Would you like to:

Address them now (I'll ask follow-up questions)

Proceed to technical requirements (address later)

Review the gaps and decide"

Next Steps

After completing the business requirements interview and gap analysis:

Review gap analysis report
Address any critical gaps
Use /technical-requirements-interview to derive technical specifications
Use /implementation-planner to generate implementation plans

Examples

See examples/ for sample output files.