requirements-elicitation
Skill0 starsChanged 6 months agoMITView on GitHub
Structured interview to turn a vague brief or idea into concrete, actionable requirements. Use when the user has a project concept, feature idea, or problem statement that needs sharpening before design or implementation begins. Triggers include "I want to build", "I have an idea for", "help me scope this", "what should the requirements be", "write requirements for", "help me define this project", "what do I need to think about before building", "scope this out", or any situation where the user has intent but not yet a clear specification. Also use when the user shares a brief or PRD that feels incomplete and wants to identify gaps.
5 other projects use a version of this.
Adopted by
Most recently taken up by
- mtarcure/claude-vibe-squadtheir own version, first seen Oct 28, 2026
- chinthakat/agent-skillstheir own version, first seen Sep 21, 2026
- dwsilvar/LBaCtheir own version, first seen Jul 28, 2026
- 45ck/business-analysis-skillstheir own version, first seen Mar 28, 2026
- Exploration-labs/Nates-Substack-Skillstheir own version, first seen Oct 18, 2025
Other versions5 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 5
- mtarcure/claude-vibe-squad★ 220same name
- Exploration-labs/Nates-Substack-Skills★ 55same name
- 45ck/business-analysis-skills★ 28same name
- chinthakat/agent-skills★ 0same name
- dwsilvar/LBaC★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository9 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- design-thinking-ideationSkill
- graph-of-thoughtSkill
- implementation-specSkill
- research-briefSkill
- trade-off-analysisSkill
- tree-of-thoughtSkill
- value-chain-analysisSkill
- vrio-analysisSkill
The file
We split this skill into the rules it gives an agent
6 rules. 0 are common, 6 are distinctive, and 0 are very specific to this project.
0
Common
Most of the 5 edited versions we read keep these.
6
Distinctive
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 35
Do NOT use when:
- Distinctive: line 47
Start by understanding what the user is trying to achieve, not what they want to build.
- Distinctive: line 84
Don't ask about all of these robotically.
- Distinctive: line 90
Not everything is equally important.
- Distinctive: line 117
If no additional tools are connected, skip this step.
- Distinctive: line 168
After requirements are captured, the natural next steps are:
“Common” is measured: kept by at least 6 in 10 of the 5 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Requirements Elicitation — From Vague Brief to Clear Spec
What This Skill Does
This skill runs a structured elicitation process that transforms a rough idea or vague brief into a concrete set of requirements. It surfaces assumptions, identifies gaps, forces prioritisation, and produces a document the user can hand to a team or use as a project foundation.
It is not a template filler — it's an interactive process that asks targeted questions to draw out what the user knows (and doesn't know they know) about what they want to build.
When to Use This Skill
Use when:
- The user has a project idea but hasn't formalised requirements
- A brief or PRD exists but feels incomplete or hand-wavy
- The user is about to start building and wants to think it through first
- Someone says "I want to build X" without specifying what X actually does
Do NOT use when:
- Requirements already exist and the user wants to implement them
- The user wants architecture or design decisions (use tree-of-thought or graph-of-thought)
- The task is a small, well-defined piece of work (just do it)
Process
Phase 1 — Understand the Intent
Start by understanding what the user is trying to achieve, not what they want to build. These are different questions.
- What problem does this solve? — Who has the problem? How do they deal with it today? What's the cost of the status quo?
- What does success look like? — If this project works perfectly, what's different in 6 months? Be specific.
- Who are the users? — Primary users, secondary users, administrators, stakeholders who don't use it but care about it.
Present a brief summary of intent and confirm with the user before moving on.
Phase 2 — Functional Requirements
Walk through the core capabilities. For each, capture:
- What it does — plain language description of the behaviour
- Input — what triggers it or what data does it need
- Output — what the user sees or what changes in the system
- Happy path — the expected flow when everything works
- Edge cases — what happens when inputs are unexpected, missing, or malformed
Group related capabilities into logical clusters. Don't aim for exhaustive coverage in the first pass — aim for the 5-8 capabilities that define the core product.
Phase 3 — Non-Functional Requirements
Probe the constraints that won't appear in a feature list but shape every decision:
- Performance — response time expectations, throughput, concurrent users
- Scale — how much data, how many users, growth expectations
- Security — authentication, authorisation, data sensitivity, compliance
- Reliability — uptime expectations, disaster recovery, data loss tolerance
- Cost — budget constraints, ongoing operational cost tolerance
- Maintainability — who maintains it, how often does it change, team size/skills
- Integration — what existing systems does it need to talk to
Don't ask about all of these robotically. Pick the 3-4 that matter most based on the project context and probe those. Mention the others briefly and let the user flag any that need deeper discussion.
Phase 4 — Prioritise
Not everything is equally important. Force a prioritisation using MoSCoW:
- Must have — the project fails without these
- Should have — significant value, expected by users, but workarounds exist
- Could have — nice to have if time/budget allows
- Won't have (this version) — explicitly out of scope for now
Present the requirements grouped by priority. This is where the user often realises they've been treating everything as a must-have, and the conversation gets productive.
Phase 5 — Gaps and Risks
Surface what's still unknown or risky:
- Open questions — things that need answers before building can start
- Assumptions — things treated as true but not yet validated
- Dependencies — external systems, teams, or decisions this project depends on
- Risks — what could derail this, and how likely is each
Phase 6 — Delivery
Produce the full requirements document as markdown using the output template below. This is always the primary output.
Then ask the user if they would like the output additionally delivered via any connected tools (e.g. posted as an issue in a project tracker, saved to a shared document, etc.). Use whatever tools are available in the current environment. If no additional tools are connected, skip this step.
Output Template
# Requirements: [Project Name]
## 1. Problem & Intent
**Problem:** [Who has it, what it costs them]
**Success:** [What's different when this works]
**Users:** [Primary, secondary, stakeholders]
## 2. Functional Requirements
### [Capability Cluster 1]
- **FR-01:** [Description] — [Input] → [Output]
- **FR-02:** [Description] — [Input] → [Output]
### [Capability Cluster 2]
- **FR-03:** [Description]
...
## 3. Non-Functional Requirements
- **NFR-01:** [Performance — e.g. API response < 200ms at P95]
- **NFR-02:** [Security — e.g. OAuth 2.0, data encrypted at rest]
...
## 4. Priority (MoSCoW)
### Must Have
- FR-01, FR-03, NFR-01
### Should Have
- FR-02, NFR-02
### Could Have
- FR-04
### Won't Have (this version)
- [Explicitly scoped out items]
## 5. Open Questions & Risks
| Item | Type | Impact | Owner |
|------|------|--------|-------|
| [Question/risk] | Open question / Assumption / Risk | High/Med/Low | [Who resolves it] |What Comes Next
After requirements are captured, the natural next steps are:
- Research brief (research-brief skill) — investigate the technical landscape, compare approaches, and surface implementation options for the requirements.
- Trade-off analysis (trade-off-analysis skill) — if requirements surface a decision between competing approaches, run a quick structured comparison.
- Implementation spec (implementation-spec skill) — once requirements and research are done, produce a phased build plan with acceptance criteria.
Interaction Style
- Interviewer, not interrogator. Keep it conversational. One question at a time where possible; batch only when the questions are tightly related.
- Challenge vague answers. "It should be fast" → "What response time would feel fast? Under 500ms? Under 2 seconds?"
- Reflect back what you've heard before moving to the next phase. Misunderstandings caught early are cheap; caught late they're expensive.
- British English spelling and punctuation.
- Be willing to say "you probably don't need to decide this yet" for things that can be deferred without risk.
Handling Edge Cases
- User already has a detailed brief: Skip Phase 1, scan the brief for gaps, and focus on Phases 3-5 (non-functional requirements, prioritisation, and risks are almost always underdeveloped in existing briefs).
- User wants to go straight to building: Acknowledge the impulse, do a 5-minute rapid version (intent + top 5 must-haves + top 3 risks), then let them go.
- User doesn't know the answer to a question: Log it as an open question and move on. Don't stall the process.
- Scope is enormous: Suggest breaking into phases or workstreams. Elicit requirements for phase 1 only, and capture the rest as "future scope."
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

