Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup
Open on GitHub

What 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-startup

This installs the whole team plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill requirements-elicitation -a claude-code

3Manually: put the files in place

~/.claude/skills/requirements-elicitation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/requirements-elicitation/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set50

The whole set →
architecture-selection architecture-selection is a Claude Code skill that compares architecture patterns against project needs and documents a recommendation. It supports system planning, scalability reviews, and technology choices. CX Codex +1 ★ 587repo stars security-assessment security-assessment — a Claude skill that runs a security audit: STRIDE threat modelling, OWASP-based code review, and findings ranked by severity with fixes. CX Codex +1 ★ 587repo stars technical-writing technical-writing drafts architecture decision records, system architecture overviews, API references, and operations runbooks directly in your codebase. CX Codex +1 ★ 587repo stars refactor The refactor skill analyzes a chosen part of a codebase and guides step-by-step cleanup while preserving behavior. Use it to improve readability without changing business logic. CX Codex +1 ★ 587repo stars pattern-detection pattern-detection finds naming conventions, architectural layers, and test styles across files. Keeps generated code aligned with repository habits. CX Codex +1 ★ 587repo stars monitor-production The monitor-production subagent plans production metrics, logs, traces, alerts, and dashboards. Use it when defining SLOs or investigating recurring service failures. CX Codex ★ 587repo stars review-compatibility review-compatibility — a subagent for Claude Code that examines code for breaking changes to APIs, databases, and configs. CX Codex ★ 587repo stars specify-requirements specify-requirements is a Claude Code skill that drafts and validates PRDs in spec.md, structuring user stories and acceptance criteria. CX Codex +1 ★ 587repo stars

Project sponsors

Companies that keep this analytics open