srs-generator
Automates the creation of formal IEEE 830 SRS documents based on raw input and project context.
Install
mkdir -p .claude/skills/srs-generator && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13354" && unzip -o skill.zip -d .claude/skills/srs-generator && rm skill.zipInstalls to .claude/skills/srs-generator
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.
Generate IEEE 830 SRS from raw requirements. Use when the user says "write SRS", "generate requirements doc", "analyze requirements", "I have raw requirements from a client", or pastes a client email/chat/PRD.Key capabilities
- →Brainstorm project context by asking system type, primary users, and core problem.
- →Extract actors, features, constraints, and out-of-scope signals from raw input.
- →Scan for gaps using a gap-detection guide.
- →Clarify P1 (blockers), P2 (functional details), and P3 (non-functional) gaps with the user.
- →Generate an IEEE 830 SRS document.
- →Populate SRS sections with gathered information, including IN/OUT tables and functional requirements.
How it works
This skill guides the user through a structured process of brainstorming, extracting, gap scanning, and clarifying raw requirements to generate an IEEE 830 SRS document.
Inputs & outputs
When to use srs-generator
- →Formalizing raw client notes into project docs
- →Ensuring alignment on project scope
- →Standardizing requirements across team documentation
About this skill
srs-generator — IEEE 830 SRS from Raw Requirements
Pipeline: Brainstorm → Receive → Extract → Gap Scan → Clarify (P1 → P2 → P3) → Generate → Review Gate → Save
Reference files (load before starting):
.codex/skills/srs-generator/references/srs-template.md.codex/skills/srs-generator/references/gap-detection-guide.md
Context files (load if present — created by .codex/scripts/init_project.py):
projects/{name}/_context/vision.md→ pre-fills §1.2 Scope and §2.1projects/{name}/_context/features.md→ pre-fills §2.2 and IN/OUT tableprojects/{name}/_context/tech_stack.md→ pre-fills §3.5 Design Constraintsprojects/{name}/_context/glossary.md→ pre-fills Appendix Aprojects/{name}/_context/quality_standards.md→ pre-fills §3.3–§3.6 NFR
If context files exist: skip Brainstorm Gate questions already answered there.
Brainstorm Gate — Understand Context First
Do NOT ask for raw requirements yet. First understand project context.
Ask these 3 questions in one batch:
- System type: Web app / Mobile app / API / Internal tool / SaaS / Desktop / Other?
- Primary users: Who will use this system? (end customers, internal staff, admins, B2B clients…)
- Core problem: What problem does this system solve? (1–2 sentences)
Wait for answers. Use responses to seed §2.1 Product Perspective, §2.3 User Characteristics, and §1.2 Scope.
After receiving answers, prompt:
Context noted. Now paste your raw requirements — any format works:
client email, bullet list, chat transcript, PRD draft.
Wait for raw input, then proceed to Step 0.
Step 0 — Receive Input
Read full input silently. Emit:
Input received: ~{N} words | type: [email prose | bullet list | partial PRD | mixed]
Step 1 — Extract & Classify
Output structured block:
- Actors — named and implied stakeholders. Tag undefined:
[GLOSSARY-GAP: {actor}] - Features — FR-01, FR-02… in "Subject can do X" form. Note strategy: prose / bullets / PRD
- Constraints — verbatim fragments only (tech stack, deadline, compliance, budget)
- Out-of-Scope signals — explicit exclusions. If absent:
[CONTEXT-GAP: no out-of-scope boundary stated]
Append [Source: {location}] to every item.
Step 2 — Gap Scan
Load .codex/skills/srs-generator/references/gap-detection-guide.md. Run all 7 patterns. Output:
| # | Priority | Pattern | Verbatim fragment / missing element |
|---|
Zero gaps → state explicitly, jump to SRS Generation.
Step 3 — Round 1 Clarification (P1 — Blockers)
If P1 gaps exist, ask the user with ≤7 questions. Label:
Round 1 of 3 — Scope & Actors (P1 — must resolve before writing SRS)
On receipt: integrate, mark resolved gaps. Unanswered P1 → [CONTEXT-GAP: {desc}] → Appendix B.
Block only if zero actors AND zero scope remain. Then proceed to Round 2.
Step 4 — Round 2 Clarification (P2 — Functional Details)
If P2 gaps remain, ask the user with ≤7 questions. Label:
Round 2 of 3 — Functional Details (P2)
Unanswered → log assumed default in SRS and Appendix B. Then proceed to Round 3.
Step 5 — Round 3 Clarification (P3 — Optional)
Ask the user with ≤7 questions. Label:
Round 3 of 3 — Non-Functional & Secondary Details (P3 — optional)
Reply 'skip' to use [TBD] placeholders.
On "skip": mark all P3 gaps [TBD: {condition} | owner: {role} | resolve-by: sprint planning].
Proceed to SRS Generation.
SRS Generation
Populate .codex/skills/srs-generator/references/srs-template.md with all gathered information.
§1.2 Scope — mandatory IN / OUT table for every feature area.
§3.2 Functional Requirements — each FR block:
FR-NN [Essential|Conditional|Optional]
Requirement: The system shall {verb} {object} when {condition}.
Actor: {role}
Precondition: {state}
Given: {context}
When: {trigger — exactly one}
Then: {externally observable outcome}
Source: [{location}]
Non-observable "Then" → [VERIFIABILITY-FAIL: FR-NN] → Appendix B
§3.3–§3.6 NFR — Quality Attribute Scenario (ISO/IEC 25023):
NFR-NN [{ISO/IEC 25010 characteristic}]
Source / Stimulus / Environment / Artifact / Response / Response Measure: {numeric}
After populating, run IEEE 830 quality checklist from gap-detection-guide.md. Output verdict:
COMPLIANT— all sections present, Appendix B emptyPARTIALLY COMPLIANT— sections present, Appendix B has open itemsNON-COMPLIANT— required sections missing
Human Review Gate
Review complete. SRS is {verdict}.
Open issues: {count} (see Appendix B).
Proceed to save? [Y / n]
Wait for explicit confirmation before writing any file.
Save & Report
- Derive slug from §1.2 product name (lowercase, hyphenated). Fallback: ask user.
- Path:
docs/srs-{slug}-{YYYYMMDD}.md - Echo absolute path, wait for confirmation.
- Create
docs/if absent, write file, confirm:"Saved ✓ {absolute_path}"
When not to use it
- →When the user does not need an IEEE 830 SRS document.
- →When the user does not have raw requirements to process.
- →When the user does not want to go through a structured brainstorming and clarification process.
Limitations
- →It relies on the user's input for clarification rounds.
- →It requires specific context files to pre-fill sections, otherwise, it will ask questions.
- →It will mark non-observable 'Then' statements in functional requirements as VERIFIABILITY-FAIL.
How it compares
This skill provides a guided, iterative process for SRS generation with built-in gap detection and clarification rounds, ensuring a complete and compliant document, unlike simply converting raw text to a template.
Compared to similar skills
srs-generator side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| srs-generator (this skill) | 0 | 1mo | No flags | Intermediate |
| skill-development | 17 | 9mo | Review | Intermediate |
| skill-writer | 27 | 9mo | Review | Beginner |
| microsoft-skill-creator | 6 | 4mo | Review | Advanced |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by DangQuangSE
View all by DangQuangSE →You might also like
skill-development
anthropics
This skill should be used when the user wants to "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content", or needs guidance on skill structure, progressive disclosure, or skill development best practices for Claude Code plugins.
skill-writer
pytorch
Guide users through creating Agent Skills for Claude Code. Use when the user wants to create, write, author, or design a new Skill, or needs help with SKILL.md files, frontmatter, or skill structure.
microsoft-skill-creator
MicrosoftDocs
Create agent skills for Microsoft technologies using Learn MCP tools. Use when users want to create a skill that teaches agents about any Microsoft technology, library, framework, or service (Azure, .NET, M365, VS Code, Bicep, etc.). Investigates topics deeply, then generates a hybrid skill storing essential knowledge locally while enabling dynamic deeper investigation.
cartographer
kingbootoshi
Maps and documents codebases of any size by orchestrating parallel subagents. Creates docs/CODEBASE_MAP.md with architecture, file purposes, dependencies, and navigation guides. Updates CLAUDE.md with a summary. Use when user says "map this codebase", "cartographer", "/cartographer", "create codebase map", "document the architecture", "understand this codebase", or when onboarding to a new project. Automatically detects if map exists and updates only changed sections.
creating-skills
letta-ai
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Letta Code's capabilities with specialized knowledge, workflows, or tool integrations.
add-pattern
langroid
Use this skill when you learn one or more design pattern(s) in the Langroid (multi) agent framework, and want to make a note for future reference for yourself. Use this either autonomously, or when asked by the user to record a new pattern.