analyze-requirements
Converts feature ideas into formal User Stories and Product Backlog Items by analyzing the codebase for feasibility.
Install
mkdir -p .claude/skills/analyze-requirements && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/15361" && unzip -o skill.zip -d .claude/skills/analyze-requirements && rm skill.zipInstalls to .claude/skills/analyze-requirements
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Requirements analysis and PBI writing workflow. Transforms user feature requests into structured User Stories with acceptance criteria, PBI breakdowns with story point estimates, impact assessments, and dependency maps. Analyzes actual codebase for feasibility and reuse opportunities. Outputs polished markdown requirements, using specs/<feature-id>-<slug>/spec.md as the canonical home for non-trivial work and docs/requirements/ only for backlog-intake artifacts. Use when asked to write a story, create PBIs, analyze requirements, or plan a feature.Key capabilities
- →Capture user intent for feature requests
- →Analyze codebase for reuse opportunities and dependencies
- →Decompose stories into implementable PBIs
- →Assess impact of new features
- →Choose canonical output location for requirements
How it works
This skill transforms user feature requests into structured requirements by capturing intent, analyzing the codebase for feasibility, writing user stories, decomposing them into PBIs, and assessing impact.
Inputs & outputs
When to use analyze-requirements
- →Formalizing feature requests
- →Planning sprints
- →Refining backlog items
About this skill
Analyze Requirements — From Idea to Structured PBIs
Transform vague feature ideas into structured, implementable requirements by combining user intent with actual codebase analysis.
When to Use
- User describes a feature idea and wants it formalized as a Story/PBI
- User asks "I want to add X" or "we need Y functionality"
- Backlog grooming — refining rough items into implementable PBIs
- Requirements clarification before sprint planning
- Keywords: "write story", "create PBI", "analyze requirement", "plan feature", "define scope"
Workflow
Step 1: Capture Intent
From the user's input, extract:
- What they want (capability)
- Who it's for (persona)
- Why it matters (business value)
- Where it fits (module, screen, API)
- Ask clarifying questions if any of these are unclear
Step 2: Codebase Analysis
Always analyze the codebase before writing requirements.
- Search for related entities, services, endpoints
- Identify existing components that can be reused
- Find existing patterns to follow
- Map affected modules and dependencies
- Check for conflicting business rules
Output a reuse assessment table:
| Component | Exists? | Action Needed |
|---|---|---|
| [Entity] | ✅ Yes | Extend with new fields |
| [Service] | ✅ Yes | Add new method |
| [Endpoint] | ❌ No | Create new |
| [Tests] | ✅ Partial | Add new scenarios |
Step 3: Write User Story
Use standard format:
- As a [persona] I want [capability] So that [benefit]
- Acceptance Criteria in Given/When/Then format
- Mark priority: Must Have / Should Have / Could Have
- Define what's Out of Scope
Step 4: PBI Decomposition
Break the story into implementable PBIs:
- Each PBI ≤ 8 story points (split larger ones)
- Each PBI has: description, acceptance criteria, technical notes, DoD
- Map dependencies between PBIs
- Assign story points based on actual codebase complexity
Step 5: Impact Assessment
Produce:
- Affected areas table (🔴🟡🟢 impact levels)
- PBI dependency graph
- Risk assessment with mitigations
- Estimation summary
Step 6: Choose the Canonical Output
Use one canonical home for the result:
- Non-trivial, multi-module, or requirement-heavy work: save or promote the output into
specs/<feature-id>-<slug>/spec.mdso downstream review, planning, and implementation use the same artifact. - Backlog intake or pre-spec triage only: save to
docs/requirements/[feature-name]-requirements.mdwhen the repo explicitly wants a lightweight intake artifact.
If both files exist, state plainly that specs/<feature-id>-<slug>/spec.md is canonical and docs/requirements/ is only a summary or intake note.
Validation
- Every user story has acceptance criteria
- Every PBI has Definition of Done
- Story points are realistic (based on codebase analysis)
- Dependencies are clearly mapped
- Out-of-scope items are explicitly listed
- Technical notes reference actual file paths
- Canonical artifact home is identified explicitly
- Output is saved as markdown file
When not to use it
- →When the feature idea is already fully formalized
- →When the task is only about typo fixes or formatting edits
- →When the codebase analysis is not required
Limitations
- →Each PBI must be ≤ 8 story points
- →Every user story must have acceptance criteria
- →Every PBI must have a Definition of Done
How it compares
This skill integrates codebase analysis directly into the requirements writing process, ensuring feasibility and identifying reuse opportunities, unlike purely abstract requirements gathering.
Compared to similar skills
analyze-requirements side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| analyze-requirements (this skill) | 0 | 3mo | Review | Intermediate |
| pmbok-project-management | 38 | 9mo | No flags | Intermediate |
| project-planner | 32 | 10mo | Review | Intermediate |
| spec-kit-workflow | 11 | 8mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by vndkubi
View all by vndkubi →You might also like
pmbok-project-management
jgtolentino
Comprehensive PMP/PMBOK project management methodologies and best practices. Use this skill when users need guidance on project management processes, templates, knowledge areas, process groups, tools, techniques, or certification preparation. Covers all 10 PMBOK Knowledge Areas and 5 Process Groups with practical templates, frameworks, and industry-standard approaches. Includes risk management, stakeholder engagement, schedule management, cost control, quality assurance, and resource planning.
project-planner
adrianpuiu
Comprehensive project planning and documentation generator for software projects. Creates structured requirements documents, system design documents, and task breakdown plans with implementation tracking. Use when starting a new project, defining specifications, creating technical designs, or breaking down complex systems into implementable tasks. Supports user story format, acceptance criteria, component design, API specifications, and hierarchical task decomposition with requirement traceability.
spec-kit-workflow
jmanhype
Guides specification-driven development workflow. Automatically invoked when discussing new features, specifications, technical planning, or implementation tasks. Ensures proper workflow phases (specify → clarify → plan → checklist → tasks → analyze → implement).
product-manager-toolkit
davila7
Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development.
planning-agent
parcadei
Planning agent that creates implementation plans and handoffs from conversation context
pdd
mikeyobrien
Transforms a rough idea into a detailed design document with implementation plan. Follows Prompt-Driven Development — iterative requirements clarification, research, design, and planning.