playbooks

home / skills / dasien / claudemultiagenttemplate / requirements-elicitation

requirements-elicitation skill

/templates/.claude/skills/requirements-elicitation

This skill extracts complete requirements from specifications, clarifies ambiguities, and identifies constraints to produce actionable acceptance criteria.

npx playbooks add skill dasien/claudemultiagenttemplate --skill requirements-elicitation

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.6 KB
---
name: "Requirements Elicitation"
description: "Extract complete, unambiguous requirements from specifications by identifying functional/non-functional requirements and clarifying ambiguities"
category: "analysis"
required_tools: ["Read", "Write", "Grep"]
---

# Requirements Elicitation

## Purpose
Extract complete, unambiguous requirements from user specifications, identifying what needs to be built while clarifying unclear or missing information.

## When to Use
- Analyzing new feature requests
- Processing enhancement specifications
- Breaking down large features into components
- Identifying missing information in requirements

## Key Capabilities
1. **Extract Requirements** - Identify functional and non-functional requirements
2. **Clarify Ambiguities** - Flag unclear specifications and ask targeted questions
3. **Identify Constraints** - Find technical, business, and resource limitations

## Approach
1. Read entire specification thoroughly
2. Extract explicit requirements (stated clearly)
3. Identify implicit requirements (assumed but not stated)
4. Flag ambiguities and inconsistencies
5. Document acceptance criteria for each requirement

## Example
**Context**: Feature request to "add export functionality"

**Approach**:
- What formats? (CSV, JSON, PDF?)
- What data to export? (All fields or subset?)
- Who can export? (All users or admins only?)
- Size limits? (Max rows, file size?)
- Output: Clear requirements with acceptance criteria

## Best Practices
- ✅ Ask "what" questions, not "how"
- ✅ Document assumptions explicitly
- ✅ Create testable acceptance criteria
- ❌ Avoid: Making technical implementation decisions

Overview

This skill extracts complete, unambiguous requirements from user specifications, turning vague requests into actionable, testable items. It identifies functional and non-functional requirements, surfaces constraints, and produces clear acceptance criteria. The goal is to reduce rework and clarify scope before design or implementation begins.

How this skill works

The skill reads the full specification to capture explicit statements and then infers implicit requirements that are likely assumed but unstated. It flags ambiguities and inconsistencies and formulates targeted clarification questions. Finally, it outputs a structured list of requirements with associated acceptance criteria and noted constraints.

When to use it

  • Analyzing new feature requests or product ideas
  • Processing enhancement or change specifications
  • Breaking down large features into discrete, implementable tasks
  • Preparing for sprint planning or design reviews
  • Validating stakeholder-provided requirements before development

Best practices

  • Ask targeted "what" and "who" questions rather than prescribing implementation details
  • Document assumptions and dependencies explicitly alongside each requirement
  • Separate functional from non-functional requirements for testability
  • Define clear, measurable acceptance criteria for every requirement
  • Flag unknowns early and prioritize clarifying high-risk ambiguities

Example use cases

  • Turn a vague request like "add export functionality" into specific requirements: formats, data scope, permissions, limits, and acceptance tests
  • Review a product spec to list functional, performance, and security requirements before planning
  • Break a large feature into sub-requirements and identify missing data or stakeholder decisions
  • Create a requirements checklist to feed into QA test cases and user acceptance testing
  • Identify constraints such as supported platforms, data retention rules, and third-party limits to prevent late surprises

FAQ

What types of requirements are produced?

Both functional (behavior, workflows) and non-functional (performance, security, reliability), plus acceptance criteria and constraints.

How are ambiguities handled?

Ambiguities are flagged and converted into concise, targeted clarification questions for stakeholders, prioritized by risk and impact.

Will this skill prescribe implementation details?

No. It focuses on what must be built and why, not on specific technical solutions; implementation decisions are left to design teams.