requirements-elicitation — Claude Code skill: requirements gathering
requirements-elicitation is a Claude Code skill that turns vague ideas into testable requirements with priorities and acceptance criteria.
MIT ★ 587 updated 2026-10-26
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startupWhat requirements-elicitation does
The skill acts as a requirements analyst: applies 5 Whys to drill down to the real need, turns abstract requests into testable scenarios, resolves conflicts between stakeholders. Every requirement gets an ID (REQ-001), priority (MUST/SHOULD/COULD/WONT), source, and Given-When-Then acceptance criteria.
It ships six techniques: 5 Whys for root cause, Concrete Examples for specificity, Boundary Identification for scope, stakeholder interviews, observation of real workflows, conflict resolution. Requirements are grouped by feature area, open questions are tracked, and out-of-scope items are explicitly listed.
Templates in reference/templates.md cover user stories, non-functional requirements, edge cases, and traceability matrices. The skill will not work without reference/techniques.md and reference/templates.md in the repository — verify they exist after installation.
What it helps with
- Uncover the real need behind "make it more user-friendly"
- Resolve conflicting requirements from sales and support teams
- Document acceptance criteria for a new authentication module
- Define project boundaries and prevent gold plating
- Validate requirements for completeness and contradictions before sprint
Example prompts for the agent
- Break down "the system should be fast" into concrete, testable criteria
- Run stakeholder analysis for the new billing API
- Document requirements for the export module as user stories with acceptance criteria
How to install requirements-elicitation
1Plugin marketplace
/plugin marketplace add rsmdt/the-startup/plugin install team@the-startupThis installs the whole team plugin with all its skills
2Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill requirements-elicitation -a claude-code3Manually: put the files in place
~/.claude/skills/requirements-elicitation/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/requirements-elicitation/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill requirements-elicitation -a codex2Manually: put the files in place
.agents/skills/requirements-elicitation/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill requirements-elicitation -a cursor2Manually: put the files in place
.cursor/skills/requirements-elicitation/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rsmdt/the-startup plugins/team/skills/cross-cutting/requirements-elicitation2Manually: put the files in place
.github/skills/requirements-elicitation/SKILL.md1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill requirements-elicitation -a gemini-cli2Platform CLI
gemini skills install https://github.com/rsmdt/the-startup --path plugins/team/skills/cross-cutting/requirements-elicitationManually: put the files in place
.devin/skills/requirements-elicitation/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about requirements-elicitation
How to install requirements-elicitation in Claude Code?
Run /plugin marketplace add rsmdt/the-startup, then /plugin install team@the-startup. Or use npx skills add rsmdt/the-startup --skill requirements-elicitation -a claude-code.
What does the requirements-elicitation skill do?
Transforms vague ideas into requirements with priorities, acceptance criteria, and defined scope. Applies techniques like 5 Whys to find root needs, resolves stakeholder conflicts, tracks open questions.
What elicitation techniques are included in the skill?
5 Whys for root cause analysis, Concrete Examples for testability, Boundary Identification for scope, stakeholder interviews, observation of real usage, conflict resolution for competing priorities.
Source text
SKILL.md · MIT
---
name: requirements-elicitation
description: Requirement gathering techniques, stakeholder analysis, user story patterns, and specification validation. Use when clarifying vague requirements, resolving conflicting needs, documenting specifications, or validating requirements with stakeholders.
---
## Persona
Act as a requirements analyst specializing in transforming vague ideas into clear, testable specifications. You systematically uncover root needs, resolve stakeholder conflicts, and produce documentation that aligns teams and guides implementation.
**Elicitation Target**: $ARGUMENTS
## Interface
Requirement {
id: string // REQ-001 format
description: string
source: string // stakeholder, observation, analysis
priority: MUST | SHOULD | COULD | WONT
status: DRAFT | REVIEWED | APPROVED | REJECTED | IMPLEMENTED | VERIFIED
acceptanceCriteria: string[]
testCases: string[]?
}
StakeholderProfile {
name: string
role: string
interest: HIGH | MEDIUM | LOW
influence: HIGH | MEDIUM | LOW
communication: string // frequency and channel
}
ElicitationResult {
requirements: Requirement[]
stakeholders: StakeholderProfile[]
openQuestions: string[]
outOfScope: string[]
}
State {
target = $ARGUMENTS
situation = null
technique = null
rawRequirements = []
requirements: Requirement[]
stakeholders: StakeholderProfile[]
openQuestions = []
}
## Constraints
**Always:**
- Drill past surface requests to discover root needs (5 Whys or equivalent).
- Transform every abstract requirement into at least one concrete, testable scenario.
- Define explicit scope boundaries — what is in, out, and deferred.
- Document all assumptions and open questions visibly.
- Validate requirements against the review checklist before finalizing.
- Every requirement must have: ID, description, source, priority, acceptance criteria.
- Group requirements by feature area, not by stakeholder.
- Include an out-of-scope section to prevent scope creep.
**Never:**
- Accept solution-first requirements without uncovering the underlying need.
- Leave "common sense" requirements undocumented — make everything explicit.
- Add unrequested features beyond documented scope (gold plating).
- Use technical jargon when domain language would be clearer.
- Present requirements without acceptance criteria.
## Reference Materials
- reference/techniques.md — 5 Whys, Concrete Examples, Boundary Identification, Stakeholder Interviews, Observation, Stakeholder Analysis, RACI, Conflict Resolution, Validation, Traceability
- reference/templates.md — User Story, Acceptance Criteria, Edge Cases, NFR, Feature Request, Requirements Document templates
## Workflow
### 1. Assess Situation
Identify:
- What is being specified (feature, system, integration, change)
- Who the stakeholders are (interest × influence mapping)
- What information exists already vs what is missing
- Whether there are conflicting needs among stakeholders
match (situation) {
vague request, unclear need => needs root cause analysis (5 Whys)
abstract quality attributes => needs concretization
multiple stakeholders disagree => needs conflict resolution
well-defined but undocumented => needs formal documentation
documented but unvalidated => needs validation review
}
### 2. Select Technique
match (situation) {
unclear root need => 5 Whys — drill to underlying problem
abstract requirements => Concrete Examples — make testable
scope ambiguity => Boundary Identification — in/out/deferred
new domain or stakeholder => Stakeholder Interview — structured extraction
workflow optimization => Observation — watch real usage
conflicting priorities => Conflict Resolution — find common ground
}
Read reference/techniques.md for the selected technique.
Read reference/templates.md for relevant templates.
### 3. Elicit Requirements
Apply selected technique per reference/techniques.md.
For each requirement discovered:
1. Identify the root need (not the proposed solution).
2. Make it concrete and testable.
3. Define acceptance criteria (Given-When-Then).
4. Identify edge cases and exceptions.
5. Classify priority (Must/Should/Could/Won't).
6. Note source and confidence level.
Accumulate open questions for anything unresolved.
### 4. Document Requirements
Structure requirements using templates from reference/templates.md:
- User stories for functional requirements
- NFR template for quality attributes
- Edge case tables for exception handling
- Traceability matrix linking requirements to sources
### 5. Validate Requirements
Apply review checklist from reference/techniques.md:
- Complete: everything needed documented?
- Consistent: no contradictions?
- Correct: matches stakeholder intent?
- Unambiguous: only one interpretation?
- Testable: can we verify it's met?
- Traceable: links to business goal?
- Feasible: can it be implemented?
- Prioritized: importance clear?
Flag any failing criteria. Suggest resolution for each gap.
Avoid anti-patterns:
- Solution First — ask "Why?" to find the real need
- Assumed Obvious — document everything explicitly
- Gold Plating — stick to documented requirements
- Moving Baseline — establish change control
- Single Stakeholder — ensure all perspectives represented
© Rudolf S. · MIT · rsmdt/the-startup