SR

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.zip

Installs 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.
209 chars✓ has a “when” trigger
Intermediate

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

You give it
Raw requirements (client email, bullet list, chat transcript, PRD draft)
You get back
IEEE 830 SRS document saved as docs/srs-{slug}-{YYYYMMDD}.md

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.1
  • projects/{name}/_context/features.md → pre-fills §2.2 and IN/OUT table
  • projects/{name}/_context/tech_stack.md → pre-fills §3.5 Design Constraints
  • projects/{name}/_context/glossary.md → pre-fills Appendix A
  • projects/{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:

  1. System type: Web app / Mobile app / API / Internal tool / SaaS / Desktop / Other?
  2. Primary users: Who will use this system? (end customers, internal staff, admins, B2B clients…)
  3. 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:

#PriorityPatternVerbatim 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 empty
  • PARTIALLY COMPLIANT — sections present, Appendix B has open items
  • NON-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

  1. Derive slug from §1.2 product name (lowercase, hyphenated). Fallback: ask user.
  2. Path: docs/srs-{slug}-{YYYYMMDD}.md
  3. Echo absolute path, wait for confirmation.
  4. 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.

SkillInstallsUpdatedSafetyDifficulty
srs-generator (this skill)01moNo flagsIntermediate
skill-development179moReviewIntermediate
skill-writer279moReviewBeginner
microsoft-skill-creator64moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

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.

17145

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.

27126

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.

626

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.

37

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.

37

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.

10

Search skills

Search the agent skills registry