Requirements Writing logo

Requirements Writing

Community
jgsystemsconsulting
requirements-writing

Guidance on writing high-quality requirements: the requirement quality characteristics and the EARS (Easy Approach to Requirements Syntax) patterns — ubiquitous, event-driven, state-driven, optional-feature, unwanted-behaviour — for unambiguous, singular, verifiable requirements, plus defect/anti-pattern review and verification & traceability. Use when authoring or reviewing requirements. Original synthesis citing EARS (Mavin et al.) and NASA public-domain guidance; not a reproduction of ISO/IEC/IEEE 29148 or the EARS paper.

Overview

Publisherjgsystemsconsulting
Repositoryjgs-se-knowledge-packs
Skill namerequirements-writing
Stars
121
Forks
1
Bundled files
10
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 10 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by jgsystemsconsulting on GitHub. Read the source before you install it.

Installation

Install the Requirements Writing AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/jgsystemsconsulting/jgs-se-knowledge-packs/tree/main/packs/requirements-writing
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/jgsystemsconsulting/jgs-se-knowledge-packs.git /tmp/jgs-se-knowledge-packs
mkdir -p .claude/skills
cp -r /tmp/jgs-se-knowledge-packs/packs/requirements-writing .claude/skills/requirements-writing
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Requirements Writing in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Requirements Writing on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Requirements Writing is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Requirements Writing Guidance — EARS & Requirement Quality

Source: Original guidance by JG Systems Consulting Ltd. (methods cited: EARS / Mavin et al. 2009; quality & verification guidance per NASA public-domain SE guidance) | Chapters: 6

When to use

Use this pack when you are writing or reviewing requirements and want them unambiguous, singular, and verifiable. It gives you the quality characteristics a requirement must pass, the EARS sentence patterns that remove most ambiguity, a defect catalogue for review, and how to make requirements verifiable and traceable. Best for behavioural/functional requirements; it points to the authoritative standards rather than reproducing them.

Prerequisites: none — this pack is plain Markdown; no MCP server, API key, or licence tier is needed at runtime.

How to Use This Skill

  • Without arguments — load the EARS patterns and the quality checklist below.
  • With a topic — ask about EARS event-driven, unambiguous, weak words, verifiability.
  • With a chapter — ask for ch03 (the EARS patterns).

Supporting files: glossary.md, patterns.md, cheatsheet.md (the EARS pattern-picker + banned-words list).

Core Frameworks & Mental Models

The quality characteristics (Ch 1). Every single requirement should be necessary, appropriate (what not how), unambiguous, complete, singular, feasible, verifiable, correct, conforming. The two-question gate that catches most damage: is it necessary? and can I write a pass/fail test?

EARS — Easy Approach to Requirements Syntax (Ch 2–4). A small set of natural-language templates (Mavin et al., 2009) that keep requirements in plain English while forcing a named system, an explicit trigger, and a single response. Choose the pattern by the trigger:

  • Ubiquitous — always on: The <system> shall <response>.
  • Event-driven (When) — When <trigger>, the <system> shall <response>.
  • State-driven (While) — While <state>, the <system> shall <response>.
  • Optional-feature (Where) — Where <feature>, the <system> shall <response>.
  • Unwanted-behaviour (If/Then) — If <condition>, then the <system> shall <response>. (faults & safety)
  • Complex — combinations, kept readable.

The defect catalogue (Ch 5). EARS fixes the shape; content defects need a separate pass: ambiguity, compound requirements, embedded design, weak/vague words, unverifiability, missing rationale — each with a standard remedy.

Verifiability & traceability (Ch 6). Assign a verification method (Test / Analysis / Inspection / Demonstration) as you write; make responses measurable (value + units + tolerance + condition); maintain bidirectional traceability up to the need and down to evidence. Keep verification ("thing right") distinct from validation ("right thing").

Chapter Index

#SectionKey content
ch01What makes a good requirementthe nine quality characteristics; the necessary+verifiable gate
ch02EARS overviewconstrained natural language; why a small ruleset works
ch03The EARS patternsUbiquitous / When / While / Where / If-Then / Complex + examples
ch04Applying EARSpattern selection; convert-in-place; before/after examples
ch05Defects & anti-patternsambiguity, compounding, embedded design, weak words, unverifiability
ch06Verifiability & traceabilityT/A/I/D methods; measurable responses; bidirectional trace

Topic Index

  • EARS patterns (When/While/Where/If-Then) → ch03, ch04
  • Complex pattern (state + event) → ch03
  • Quality characteristics (necessary, unambiguous, singular…) → ch01
  • Ambiguity / weak words / compound requirements → ch05
  • Embedded design in requirements → ch05, ch01
  • Verifiability / verification methods (T/A/I/D) → ch06
  • Traceability / verification vs validation → ch06
  • Converting legacy requirements → ch04
  • Measurable response / tolerances → ch06, ch03

Supporting Files

  • glossary.md — key terms (EARS patterns, quality characteristics, verification methods)
  • patterns.md — the EARS patterns + review techniques, as when/how/trade-offs
  • cheatsheet.md — EARS pattern-picker table, quality checklist, decision rules, banned-words list, tells & smells

Scope & Limits

This is original guidance written by JG Systems Consulting Ltd., synthesising widely-taught requirements practice. It cites its methods rather than reproducing them: the EARS patterns are credited to Mavin et al. (2009) and described in original words; the quality and verification material aligns with NASA public-domain SE guidance (NPR 7123.1 / SE Handbook). It is not a reproduction of ISO/IEC/IEEE 29148, the INCOSE Guide for Writing Requirements, or the EARS conference paper — for the authoritative text, consult those sources directly. The pack covers behavioural/functional requirement writing; it is not a full requirements-management or elicitation methodology.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Requirements Writing AI skill do?

Guidance on writing high-quality requirements: the requirement quality characteristics and the EARS (Easy Approach to Requirements Syntax) patterns — ubiquitous, event-driven, state-driven, optional-feature, unwanted-behaviour — for unambiguous, singular, verifiable requirements, plus defect/anti-pattern review and verification & traceability. Use when authoring or reviewing requirements. Original synthesis citing EARS (Mavin et al.) and NASA public-domain guidance; not a reproduction of ISO/IEC/IEEE 29148 or the EARS paper.

Why use Requirements Writing on TypingMind?

Because you install it once and use it with any model. Requirements Writing is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Requirements Writing in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/jgsystemsconsulting/jgs-se-knowledge-packs/tree/main/packs/requirements-writing. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Requirements Writing?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Requirements Writing?

As many as you like. As long as a model supports skills, you can use Requirements Writing with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Requirements Writing AI skill free?

It is published on GitHub by jgsystemsconsulting. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇