“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

FocusQuestionHandoff output
Security objectiveWhat asset or behavior must be protected, from which threat?Asset, actor, boundary, and source
TestabilityWhat observable condition distinguishes protection from failure?Acceptance condition and safe oracle
TraceabilityCan the objective be followed into design, control, and validation?Trace ID and missing link
ApplicabilityWhich role, tenant, region, platform, data class, and version apply?Explicit scope and exclusions
EvidenceWhat redacted fixture, log, metric, or review record can support the claim?Evidence state and validation action
Human decisionWhat 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:

StateMeaningHandling
knownDirectly supported by the supplied requirement, policy, or designKeep source and version with the claim
missingNeeded to define the control or acceptance conditionAsk for the smallest safe artifact
conflictingRequirement, policy, and design disagreePreserve the conflict and route a decision
staleThe source or control applies to an old version or scopeMark freshness and avoid current claims
out_of_scopeReal credentials, production probing, or unrelated assetsExplicitly exclude it
assumptionsA temporary scope or fixture assumptionState 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

LayerHow to write itExample
FactWhat the requirement, policy, or design directly statesThe requirement prohibits exporting card data
Evidence-backed InferenceWhat the missing channel rule could allowUI, API, export, and logs may diverge
RecommendationThe smallest action that makes the goal testableDefine data class, actor, channel, response, and log conditions
Human DecisionA risk, exception, or threshold choiceOwners 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

MaterialWhat to provideWhat to do when it is missing
Security objectiveAsset, threat, actor, trust boundary, and expected controlKeep undefined assets or actors open
Acceptance materialRequirement, design, policy, test idea, and trace IDsMark missing links
ApplicabilityRole, tenant, region, data class, platform, and versionDo not compare unknown scopes
Evidence planRedacted fixtures, safe environment, logs, and validation methodDo 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
FieldExample
Asset and boundaryPayment-card data viewed by support agents through the portal, API, export job, and audit path
Security objectiveThe 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 preconditionAn authenticated support agent opens an invoice and attempts an export through an applicable channel; the channel scope is not yet confirmed
Evidence statemissing; channel and data-class rules are incomplete
Trace gapThe requirement is not linked to API response fields, export behavior, logging, and acceptance cases
Expected resultAfter the owner confirms fields and channels, prohibited card-data exports should be denied; invoice views should follow the approved field policy
Impact and priorityProtection may differ by channel; the project priority rubric was not supplied, so this example does not assign a priority
Owner and decisionSecurity, privacy, support-product, and API owners confirm permitted view, copy, export, and log behavior
Close conditionEach channel has one observable allow or deny condition and a source-backed trace link
ValidationUse synthetic card data in an isolated environment; preserve responses, export files, logs, and policy version
Stop conditionStop 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 fieldWhat to retain
Source and scopeRequirement version, asset, role, channel, and exclusions for this pass
Evidence stateKnown, missing, conflicting, stale, out of scope, or assumed, with source locations
Gap and impactThe undefined control or acceptance condition, affected asset, and possible decision impact
Owner and decisionWho must confirm which rule, risk, or exception
Close and validationClose 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 gapNext ownerHandoff goal
Asset, role, or acceptance rule is undefinedProduct or security requirements ownerConfirm scope, allowed and denied behavior, and acceptance criteria
Control is named but has no observable resultDesign or API ownerSpecify failure responses, audit events, data flow, and trace fields
Control effectiveness needs validationSecurity test owner and environment ownerRun the smallest authorized check with synthetic data in an isolated environment and retain evidence
Residual risk, exception, or release impact remainsAuthorized risk ownerRecord 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

Common traps

  1. Treating a broad security adjective as an acceptance condition.
  2. Assuming a UI restriction covers direct API, export, logs, and support tooling.
  3. Calling a control secure because its name appears in a design document.
  4. 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

Static plans, file presence, and dry runs retain their evidence state. They do not become runtime proof, exploit resistance, or release approval.

Further reading

More Resources

Share