SuperAPI AI Directory
Partner with us中文AI newsFavorites
Skillsrequirements-doc-gen

requirements-doc-gen

Writing & research

View repository

Updated 10-16 01:19

About this skill

Requirement Document Generator

Task Objectives

  • This Skill is used to: convert rough business descriptions into professional Software Requirements Specifications (SRS) and Product Requirements Documents (PRD)
  • Capabilities include: interactive requirement gathering, standard document generation, existing document analysis and optimization, requirement change impact analysis, multi-platform requirement management
  • Trigger conditions: when users need to "generate requirement documents", "analyze requirement documents", "optimize requirement documents", "requirement change analysis", or describe a project that needs to be documented

Prerequisites

Operation Steps

Scenario 1: Generate a New Document

Step 1: Understand the Initial Input

  • Read the rough description provided by the user (text or document)
  • Identify the core business scenarios and objectives
  • If the information is insufficient, proceed to Step 2 to supplement information

Step 2: Interactive Requirement Supplementation

Interact with the user step by step across the following dimensions to supplement key information:

Basic Information

  • Project background and business objectives
  • Target user persona (User Persona)
  • Core user scenarios (User Journey)
  • Project scope and boundaries

Functional Requirements

  • Use the MoSCoW method to organize the feature list:
    • Must-have
    • Should-have
    • Could-have
    • Won't-have
  • Description of core feature points (input, processing logic, output, exceptions)

Non-functional Requirements

  • Performance metrics (response time, concurrency, availability)
  • Security requirements (data encryption, access control, compliance)
  • Compatibility requirements (browser versions, operating system versions)

Multi-platform Strategy

  • Supported terminal types (Web, mobile, desktop, game platforms)
  • Description of feature differences across platforms
  • UI/UX adaptation strategy (responsive vs native)

Step 3: Generate the SRS Document

  • Based on the references/srs-template.md template
  • Fill in technical requirement details:
    • System architecture description
    • Interface requirements (API/SDK)
    • Data model
    • Technical constraints
    • Testing requirements

Step 4: Generate the PRD Document

  • Based on the references/prd-template.md template
  • Fill in business requirement details:
    • User journey map
    • Interaction flow description
    • Prototype description
    • Data tracking requirements

Step 5: Completeness Verification

Step 6: Autonomous Knowledge Completion (if needed)

  • When encountering insufficient domain-specific knowledge (such as GDPR compliance, game engine limitations, etc.)
  • Use web_search to search for relevant specifications and best practices
  • Integrate the search results into the document

Scenario 2: Analyze and optimize existing documents

Step 1: Read the existing document

  • Read the SRS or PRD document provided by the user
  • Identify the document type and completeness

Step 2: Completeness check

Step 3: Problem diagnosis

  • Analyze the problems existing in the document:
    • Missing key sections
    • Vague descriptions (using words such as "possibly", "probably", etc.)
    • Multi-platform requirements not clarified
    • Missing non-functional requirements
    • Functional requirements not verifiable

Step 4: Interactive supplementation

Step 5: Generate optimized version

  • Generate the complete document after supplementation
  • Mark modifications and newly added content
  • Provide a summary of optimization suggestions

Scenario 3: Requirement change analysis

Step 1: Read document versions

  • Read the original requirements document
  • Read the new version requirements document

Step 2: Comparative analysis

  • Identify change points:
    • Added requirements (Add)
    • Modified requirements (Modify)
    • Deleted requirements (Delete)
  • Mark the functional modules affected by the changes

Step 3: Impact scope analysis

Evaluate the change impact from the following dimensions:

Technical impact

  • Architecture design changes
  • Interface modifications (API parameter additions/removals, return value changes)
  • Data model adjustments
  • Technical dependency changes

Development impact

  • Code modules that need to be modified
  • Estimate workload
  • Development priority adjustments

Testing impact

  • Test cases that need to be added/modified
  • Regression testing scope
  • Performance testing requirements

User experience impact

  • Interface interaction changes
  • Operation process adjustments
  • User habit migration cost

Step 4: Output change report

Generate a structured change impact report, including:

  • Change list (additions, modifications, deletions)
  • Impact scope assessment
  • Risk alerts
  • Implementation suggestions

Resource index

Notes

  • Maintain the pace of interactive supplementation and avoid asking too many questions at once
  • Multi-platform requirements are a common omission point and need to be proactively identified and supplemented
  • Prioritize ensuring the verifiability and unambiguity of requirements
  • When encountering uncertain domain knowledge, proactively search rather than guess
  • After document generation, be sure to use the check list to verify completeness
  • Follow the principle of "progressive disclosure", with details linked to reference documentation

Usage Examples

Example 1: Generate a requirements document from a rough description

User input: I want to build an online exam system that supports student exams, teacher question creation, and administrator management

Execution flow：

  1. Understand the core requirements: online exam system, with the roles of student, teacher, and administrator
  2. Interactive supplementation:
    • Q: Which question types are supported? (single choice, multiple choice, true/false, fill-in-the-blank, programming, etc.)
    • Q: Exam mode? (timed/untimed, single-attempt/multiple-attempt, random question selection, etc.)
    • Q: Multi-platform requirements? (Web, mobile?)
    • Q: Performance requirements? (Maximum number of concurrent users?)
  3. Generate SRS and PRD documents
  4. Validate using the checklist
  5. Output the complete document

Example 2: Analyze and optimize an existing document

User input: This is my PRD document, please help me see what problems there are [upload document]

Execution flow：

  1. Read and analyze the document
  2. Validate item by item using the checklist:
    • ✓ Feature list complete
    • ✗ Non-functional requirements missing
    • ✗ Multi-platform differences not specified
    • ✓ User journey clear
  3. Interactively supplement missing information
  4. Generate an optimized version, marking newly added content

Example 3: Requirements change analysis

User input: The original requirement was a Web application, now mobile support needs to be added, please analyze the impact

Execution flow：

  1. Compare the original document (Web only) with the new requirement (Web + mobile)
  2. Identify changes:
    • Added: mobile adaptation requirements
    • Modified: APIs need to support multi-platform calls
    • Added: responsive layout requirements
  3. Analyze impact:
    • Technology: the frontend architecture needs adjustment, and the API needs to adapt to multiple platforms
    • Development: increased mobile development work
    • Testing: a new mobile testing environment needs to be added
    • User experience: multi-platform consistency needs to be considered
  4. Output a change impact report