kiro-spec-requirements
Generate comprehensive requirements for a specification
gotalab · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add gotalab/cc-sdd --skill kiro-spec-requirements技能说明
name: kiro-spec-requirements description: Generate comprehensive requirements for a specification metadata: shared-rules: "ears-format.md, requirements-review-gate.md"
Requirements Generation
<background_information>
- Success Criteria:
- Create complete requirements document aligned with steering context
- Follow the project's EARS patterns and constraints for all acceptance criteria
- Focus on core functionality without implementation details
- Make inclusion/exclusion boundaries explicit when scope could otherwise be misread
- Update metadata to track generation status </background_information>
-
Load Context:
- Read
{{KIRO_DIR}}/specs/$1/spec.jsonfor language and metadata - Read
{{KIRO_DIR}}/specs/$1/brief.mdif it exists (discovery context: problem, approach, scope decisions, boundary candidates) - Read
{{KIRO_DIR}}/specs/$1/requirements.mdfor project description - Core steering context:
product.md,tech.md,structure.md - Additional steering files only when directly relevant to feature scope, user personas, business/domain rules, compliance/security constraints, operational constraints, or existing product boundaries
- Relevant local agent skills or playbooks only when they clearly match the feature's host environment or use case and contain domain terminology or workflow rules that shape user-observable requirements
- Read
-
Read Guidelines:
- Read
rules/ears-format.mdfrom this skill's directory for EARS syntax rules - Read
rules/requirements-review-gate.mdfrom this skill's directory for pre-write review criteria - Read
{{KIRO_DIR}}/settings/templates/specs/requirements.mdfor document structure
- Read
Parallel Research (sub-agent dispatch)
The following research areas are independent. Decide the optimal decomposition based on project complexity -- split, merge, add, or skip sub-agents as needed.
In main context (essential for requirements generation):
- Spec files: spec.json, brief.md, requirements.md (project description)
- EARS format rules, requirements review gate, requirements template
- Core steering: product.md, tech.md (directly inform scope and constraints)
Delegate to sub-agent (keeps exploration out of main context):
- Codebase hints (brownfield projects): Spawn a sub-agent to explore existing implementations that inform requirement scope. Ask it to summarize: (1) what already exists, (2) relevant interfaces/APIs, (3) patterns that new requirements should align with. Return a summary under 150 lines.
- Domain research (when external knowledge is needed): Spawn a sub-agent for web research on domain-specific requirements, standards, or best practices. Return a concise findings summary.
- Additional steering and playbooks: If many steering files or local agent playbooks exist, spawn a sub-agent to scan them and return only the sections relevant to this feature.
For greenfield projects with minimal codebase, skip sub-agent dispatch and load context directly. If multi-agent is not available, execute sequentially in main context.
After all research completes, synthesize findings in main context before generating requirements.
-
Generate Requirements Draft:
- Create initial requirements draft based on project description
- Group related functionality into logical requirement areas
- Apply EARS format to all acceptance criteria
- Use language specified in spec.json
- Preserve terminology continuity across phases:
- discovery =
Boundary Candidates - requirements = explicit inclusion/exclusion and adjacent expectations when needed
- design =
Boundary Commitments - tasks =
_Boundary:_
- discovery =
- If scope could be misread, add lightweight boundary context without introducing implementation or architecture ownership detail
- Keep this as a draft until the review gate passes; do not write
requirements.mdyet
-
Review Requirements Draft:
- Run the
Requirements Review Gatefromrules/requirements-review-gate.md - Review coverage, EARS compliance, ambiguity, adjacent expectations, and scope boundaries before finalizing
- If issues are local to the draft, repair the requirements and review again
- Keep the review bounded to at most 2 repair passes
- If the draft exposes a real scope ambiguity or contradiction, stop and ask the user to clarify instead of writing guessed requirements
- Run the
-
Finalize and Update Metadata:
- Write
{{KIRO_DIR}}/specs/$1/requirements.mdonly after the requirements review gate passes - Set
phase: "requirements-generated" - Set
approvals.requirements.generated: true - Update
updated_attimestamp
- Write
Important Constraints
Requirements Scope: WHAT, not HOW
Requirements describe user-observable behavior, not implementation. Use this to decide what belongs here vs. in design:
Ask the user about (requirements scope):
- Functional scope — what is included and what is excluded
- User-observable behavior — "when X happens, what should the user see/experience?"
- Business rules and edge cases — limits, error conditions, special cases
- Non-functional requirements visible to users — response time expectations, availability, security level
- Adjacent expectations only when they change user-visible behavior or operator expectations — what this feature relies on, and what it explicitly does not own
Do not ask about (design scope — defer to design phase):
- Technology stack choices (database, framework, language)
- Architecture patterns (microservices, monolith, event-driven)
- API design, data models, internal component structure
- How to achieve non-functional requirements (caching strategy, scaling approach)
- Internal ownership mapping, component seams, or implementation boundaries that belong in design
Litmus test: If an EARS acceptance criterion can be written without mentioning any technology, it belongs in requirement
阅读完整来源 ↗