“The system must be secure” is a concern, not a testable requirement. A useful security review names the protected asset, actor, trust boundary, expected control, acceptance condition, and evidence source.
Why this Skill is needed
The Security Requirement Review Skill turns broad protection goals into reviewable security requirements before implementation. It exposes trace and acceptance gaps while keeping static design evidence separate from vulnerability, exploit, or security-pass claims.
What the Skill does
Use this Skill for authentication, authorization, data protection, audit, privacy, and abuse-prevention requirements supplied as redacted or synthetic material. It does not read credentials, call real APIs, or perform an exploit.
A good finding names the asset, actor and boundary, security objective, acceptance condition, trace link, evidence state, owner, close condition, and safe validation method.
Use it when a security requirement is broad, a threat-model decision must become an acceptance condition, or a design names controls without defining how success will be observed.
What it does not do
It does not replace:
- Penetration testing, red-team work, vulnerability scanning, or exploit validation.
- Real secrets, production probing, or an intrusive security action.
- Threat modeling, permission design, or implementation review.
- Risk acceptance, exception approval, or release-security judgment.
It prepares a security requirement for safe validation. It does not prove that an implementation is secure.
What it checks
| Focus | Question | Handoff output |
|---|---|---|
| Security objective | What asset or behavior must be protected, from which threat? | Asset, actor, boundary, and source |
| Testability | What observable condition distinguishes protection from failure? | Acceptance condition and safe oracle |
| Traceability | Can the objective be followed into design, control, and validation? | Trace ID and missing link |
| Applicability | Which role, tenant, region, platform, data class, and version apply? | Explicit scope and exclusions |
| Evidence | What redacted fixture, log, metric, or review record can support the claim? | Evidence state and validation action |
| Human decision | What risk, exception, or threshold requires an owner? | Decision question and accepter |
Security vocabulary is not a substitute for a condition that someone can observe and verify.
Audit inputs before you start
Classify the input before reviewing the protection goal:
| State | Meaning | Handling |
|---|---|---|
| known | Directly supported by the supplied requirement, policy, or design | Keep source and version with the claim |
| missing | Needed to define the control or acceptance condition | Ask for the smallest safe artifact |
| conflicting | Requirement, policy, and design disagree | Preserve the conflict and route a decision |
| stale | The source or control applies to an old version or scope | Mark freshness and avoid current claims |
| out_of_scope | Real credentials, production probing, or unrelated assets | Explicitly exclude it |
| assumptions | A temporary scope or fixture assumption | State its effect and safe validation |
When evidence is incomplete, return a bounded requirement review. Do not compensate with a generic security standard or an invented threshold.
From problem to structured Finding
Connect the source, scope, evidence state, analysis, owner, action, close condition, and validation before writing the conclusion. The case below keeps this Skill’s identifier and domain context.
Keep the decision layers separate
| Layer | How to write it | Example |
|---|---|---|
| Fact | What the requirement, policy, or design directly states | The requirement prohibits exporting card data |
| Evidence-backed Inference | What the missing channel rule could allow | UI, API, export, and logs may diverge |
| Recommendation | The smallest action that makes the goal testable | Define data class, actor, channel, response, and log conditions |
| Human Decision | A risk, exception, or threshold choice | Owners decide what masked viewing and audit retention mean |
The Skill can organize the choice; it cannot authorize a security exception.
A complete case
This case follows Input, Analysis, Finding, Decision, and Validation. When material is incomplete, keep missing, conflicting, or assumptions visible instead of turning them into a pass.
Input
| Material | What to provide | What to do when it is missing |
|---|---|---|
| Security objective | Asset, threat, actor, trust boundary, and expected control | Keep undefined assets or actors open |
| Acceptance material | Requirement, design, policy, test idea, and trace IDs | Mark missing links |
| Applicability | Role, tenant, region, data class, platform, and version | Do not compare unknown scopes |
| Evidence plan | Redacted fixtures, safe environment, logs, and validation method | Do not use real secrets |
Use a request like this:
Use the security-requirement-review Skill.
Task: Review a requirement that support agents may view customer invoices but must not export payment-card data.
Inputs: [security requirement, role matrix, data classification, UI/API design, audit policy, trace links]
Scope: [support portal, authenticated agents, staging]
Constraints: [no real customer data or credentials]
Assess objective, testability, trace links, acceptance conditions, and evidence gaps. Keep assumptions and Human risk decisions separate.
Analysis
Use the input, matrix, and evidence state to form the judgment before writing the Finding; keep missing material as a gap.
Finding
Example finding: SRR-02 turns protection into an observable condition
The requirement prohibits exporting card data but does not say whether masked values may be copied, downloaded through an API, or included in audit logs. This is an illustrative review pattern, not a security test result.
SRR-02 — Card-data protection is not defined across channels
| Field | Example |
|---|---|
| Asset and boundary | Payment-card data viewed by support agents through the portal, API, export job, and audit path |
| Security objective | The requirement permits support agents to view customer invoices and prohibits exporting payment-card data; it does not define which card fields may be displayed |
| Trigger and precondition | An authenticated support agent opens an invoice and attempts an export through an applicable channel; the channel scope is not yet confirmed |
| Evidence state | missing; channel and data-class rules are incomplete |
| Trace gap | The requirement is not linked to API response fields, export behavior, logging, and acceptance cases |
| Expected result | After the owner confirms fields and channels, prohibited card-data exports should be denied; invoice views should follow the approved field policy |
| Impact and priority | Protection may differ by channel; the project priority rubric was not supplied, so this example does not assign a priority |
| Owner and decision | Security, privacy, support-product, and API owners confirm permitted view, copy, export, and log behavior |
| Close condition | Each channel has one observable allow or deny condition and a source-backed trace link |
| Validation | Use synthetic card data in an isolated environment; preserve responses, export files, logs, and policy version |
| Stop condition | Stop if a check reaches real card data, leaves the isolated environment, or enters an unapproved channel; retain the record and escalate to the owner |
The finding does not claim the portal is unsafe. It says the current material cannot yet support a consistent security validation.
Decision
The accountable owner confirms the decision question and risk trade-off; the Skill does not make that choice.
Validation
Before closing the finding, run the stated validation and retain the raw artifact. Without an execution record, the status remains unverified.
How a Finding enters the next stage
Handoff output
Shape each SRR-## so the next owner can act on it:
| Handoff field | What to retain |
|---|---|
| Source and scope | Requirement version, asset, role, channel, and exclusions for this pass |
| Evidence state | Known, missing, conflicting, stale, out of scope, or assumed, with source locations |
| Gap and impact | The undefined control or acceptance condition, affected asset, and possible decision impact |
| Owner and decision | Who must confirm which rule, risk, or exception |
| Close and validation | Close condition, isolated environment, synthetic data, expected result, and raw evidence |
Next-stage route
Route work by the kind of gap. A candidate validation or review finding does not trigger formal approval on its own:
| Current gap | Next owner | Handoff goal |
|---|---|---|
| Asset, role, or acceptance rule is undefined | Product or security requirements owner | Confirm scope, allowed and denied behavior, and acceptance criteria |
| Control is named but has no observable result | Design or API owner | Specify failure responses, audit events, data flow, and trace fields |
| Control effectiveness needs validation | Security test owner and environment owner | Run the smallest authorized check with synthetic data in an isolated environment and retain evidence |
| Residual risk, exception, or release impact remains | Authorized risk owner | Record accepted scope, compensating controls, expiry, and the formal decision |
An SRR-## can enter the trace chain across requirements, design, testing, and audit. The record alone does not show that a penetration test ran.
How to prepare better input
Provide the exact security objective, asset classification, role and data matrix, trust boundaries, applicable channels, version, environment, dependencies, known controls, design links, acceptance conditions, and available evidence. Use redacted or synthetic data, and identify the authorized validation environment and stop/escalation conditions.
The output should include task and scope, the six-state input audit, requirements with triggers and expected results, evidence gaps, prioritized SRR-## findings, candidate validation, residual risks, and Human decisions. A broad statement such as “the system must be secure” leaves assets, roles, controls, and success criteria undefined. Provide those inputs so the review can produce conditions that someone can check.
Best practices
- Start with high-impact assets, permission-sensitive actions, and data-protection goals.
- Use redacted or synthetic data; keep candidate checks least-privileged, isolated, and reversible.
- Trace every acceptance condition to a requirement, design control, and owner; leave unsourced thresholds open for a decision.
Working with other Skills
- Threat Modeling: https://inaodeng.com/en/qaskills/threat-modeling/
- Secrets Exposure Review: https://inaodeng.com/en/qaskills/secrets-exposure-review/
- Authorization Testing: https://inaodeng.com/en/qaskills/authorization-testing/
- API Security Testing: https://inaodeng.com/en/qaskills/api-security-testing/
Common traps
- Treating a broad security adjective as an acceptance condition.
- Assuming a UI restriction covers direct API, export, logs, and support tooling.
- Calling a control secure because its name appears in a design document.
- Using real credentials or production data to compensate for missing evidence.
Install and invoke
npx skills add https://github.com/naodeng/awesome-qa-skills/tree/main/skills/en --skill security-requirement-review
Use the security-requirement-review Skill.
Include objective, scope, versions, evidence paths, constraints, and decision boundary.
Audit inputs first. Return findings with asset, boundary, acceptance condition, trace status, owner, close condition, and safe validation method.
FAQ
Can this Skill perform a penetration test?
No. It prepares requirement and evidence review. Security testing needs a separately authorized method and environment.
What if the owner cannot define a threshold?
Mark the acceptance condition unassessed, record the decision question, and do not replace it with a generic security standard.
References
Source Skill and execution contract
-
Security Requirement Review prompt (execution contract): https://github.com/naodeng/awesome-qa-skills/tree/main/skills/en/testing-types/security-requirement-review/prompts/security-requirement-review.md
-
Security Requirement Review Skill source directory (definition, prompt, agent adaptation, and evaluation assets): https://github.com/naodeng/awesome-qa-skills/tree/main/skills/en/testing-types/security-requirement-review
Static plans, file presence, and dry runs retain their evidence state. They do not become runtime proof, exploit resistance, or release approval.
Further reading
- Security Requirement Review details: https://inaodeng.com/en/qaskills/security-requirement-review/
- Awesome QA Skills project: https://github.com/naodeng/awesome-qa-skills
More Resources
- Personal website: https://inaodeng.com/en/
- AI-generated test detection project: https://github.com/AI-Native-QA-Lab/ai-test-auditor
- DeepSeek QA Workbench: https://github.com/naodeng/dsh-qa
- More AI testing skills: https://inaodeng.com/en/qaskills/
- More testing wiki: https://inaodeng.com/en/wiki/
- More AI Wiki: https://inaodeng.com/en/AIWiki/