Skip to main content
skill CX Codex

security-assessment — Claude Code skill: STRIDE and OWASP review

security-assessment — a Claude skill that runs a security audit: STRIDE threat modelling, OWASP-based code review, and findings ranked by severity with fixes.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup
Open on GitHub

What security-assessment does

Point it at a service or module and it works as a security engineer: STRIDE threat model over architecture and data flows first, line-by-line review after that. The audit target arrives as an argument.

Three reference files sit inside: OWASP A01–A10 patterns, secure coding notes covering input handling, output encoding, secrets storage and error handling, and a review checklist. Code is traced through seven areas: authentication and sessions, authorization, input paths, data exposure, crypto, third-party integrations, and how failures are handled.

Each finding carries a severity from CRITICAL to INFORMATIONAL, an OWASP or STRIDE category, a location, and concrete remediation. Going straight to the code is not allowed here — the skill forbids it, since trust boundaries and data flows are what make a finding readable. Output closes with a prioritised remediation plan.

What it helps with

  • Map STRIDE threats across a service and its trust boundaries
  • Trace authorization checks through every layer
  • Catch credentials or personal data leaking into logs and error messages
  • Produce a findings list sorted by severity, each with a fix
  • Review user input paths for injection flaws

Example prompts for the agent

  • Run security-assessment on src/api: STRIDE first, then authorization and input handling.
  • Audit the billing module for data exposure and session problems, sort the findings by severity.
  • Threat-model the new service and tell me what to fix first.

How to install security-assessment

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup

This installs the whole team plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill security-assessment -a claude-code

3Manually: put the files in place

~/.claude/skills/security-assessment/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/security-assessment/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about security-assessment

How do I install security-assessment in Claude Code?

Add the marketplace with /plugin marketplace add rsmdt/the-startup, then install the plugin: /plugin install team@the-startup.

What does security-assessment do?

It acts as a security engineer: builds a STRIDE threat model, reviews code against OWASP patterns, and returns findings with severity, location and remediation steps.

Does it look at infrastructure as well as code?

Yes. After the code pass it checks network segmentation, container security, secrets storage and cloud IAM against the bundled checklist.

Source text

SKILL.md · MIT
---
name: security-assessment
description: Vulnerability review, threat modeling, OWASP patterns, and secure coding assessment. Use when reviewing code security, designing secure systems, performing threat analysis, or validating security implementations.
---

## Persona

Act as a security engineer who systematically evaluates code, architecture, and infrastructure for vulnerabilities using threat modeling frameworks and practical code review techniques to identify and recommend remediations.

**Assessment Target**: $ARGUMENTS

## Interface

SecurityFinding {
  severity: CRITICAL | HIGH | MEDIUM | LOW | INFORMATIONAL
  category: string              // STRIDE category or OWASP ID
  title: string
  location: string
  vulnerability: string
  impact: string
  remediation: string
  code_example?: string
}

STRIDEThreat {
  category: Spoofing | Tampering | Repudiation | InformationDisclosure | DenialOfService | ElevationOfPrivilege
  threat: string
  questions: string[]
  mitigations: string[]
}

State {
  target = $ARGUMENTS
  architecture = {}
  threats: STRIDEThreat[]
  findings: SecurityFinding[]
  focusAreas = [
    "Authentication and session management",
    "Authorization checks",
    "Input handling",
    "Data exposure",
    "Cryptography usage",
    "Third-party integrations",
    "Error handling"
  ]
}

## Constraints

**Always:**
- Apply STRIDE threat modeling to architecture before code-level review.
- Every finding must include specific remediation steps.
- Prioritize by risk: likelihood x impact.
- Check all seven code review focus areas for every assessment.
- Reference OWASP patterns for web application security.

**Never:**
- Skip threat modeling and jump straight to code review.
- Report vulnerabilities without remediation guidance.
- Expose sensitive details (real credentials, internal paths) in findings.
- Assume security controls work without verification.

## Reference Materials

- reference/owasp-patterns.md — A01-A10 review patterns with red flags for each category
- reference/secure-coding.md — Input validation, output encoding, secrets management, error handling, infrastructure security
- checklists/security-review-checklist.md — Comprehensive checklist covering threat modeling, auth, input validation, crypto, logging, API, infrastructure, dependencies, CI/CD

## Workflow

### 1. Gather Context

Understand the system: architecture, data flows, trust boundaries, entry points.
Identify sensitive data types (credentials, PII, financial).
Map third-party integrations and their trust levels.

### 2. Model Threats

Apply STRIDE to each component and data flow:

**Spoofing (Authentication)**
Can identities be faked? Token theft/forgery? Auth bypass paths?
Mitigate with: MFA, secure token generation, session invalidation.

**Tampering (Integrity)**
Can data be modified in transit or at rest? Config alteration?
Mitigate with: input validation, cryptographic signatures, audit logs.

**Repudiation (Non-repudiation)**
Can actions be denied? Are audit logs tamper-resistant?
Mitigate with: comprehensive logging, immutable log storage, digital signatures.

**Information Disclosure (Confidentiality)**
What sensitive data exists? Protected at rest and in transit? Error messages leaking?
Mitigate with: encryption (TLS, AES), access controls, sanitized errors.

**Denial of Service (Availability)**
What resources can be exhausted? Rate limits on expensive ops?
Mitigate with: rate limiting, input size limits, resource quotas, timeouts.

**Elevation of Privilege (Authorization)**
Can users access beyond their role? Consistent privilege checks?
Mitigate with: least privilege, RBAC, authorization at every layer.

### 3. Review Code

Read reference/owasp-patterns.md for systematic OWASP Top 10 review.
Read reference/secure-coding.md for secure coding pattern verification.

For each focus area, trace data flow from entry to storage/output:
1. Authentication and session management — token lifecycle, validation.
2. Authorization checks — access control at all layers.
3. Input handling — all user input paths, injection prevention.
4. Data exposure — logs, errors, API responses.
5. Cryptography usage — algorithm selection, key management.
6. Third-party integrations — data sharing, auth mechanisms.
7. Error handling — information leakage, fail-secure behavior.

### 4. Assess Infrastructure

Review infrastructure security per reference/secure-coding.md:
Network segmentation, container security, secrets management, cloud IAM.

Read checklists/security-review-checklist.md for comprehensive validation.

### 5. Report Findings

Structure output:
1. Summary — assessment scope, methodology applied.
2. Threat model — STRIDE analysis results per component.
3. Findings table — sorted by severity with OWASP/STRIDE category.
4. Detailed findings — vulnerability, impact, remediation for each.
5. Best practices — defense in depth, assume breach, automate security testing.
6. Recommended next steps — prioritized remediation plan.

© Rudolf S. · MIT · rsmdt/the-startup

Similar skills

All skills for Security →

From the same set50

The whole set →
test-strategy The test-strategy subagent for Claude Code plans and runs risk-prioritized functional and performance checks, assessing coverage, bottlenecks, and release readiness. CX Codex ★ 587repo stars testing testing — a skill for writing effective tests: layer-specific mocking rules, failure debugging, flaky test management. CX Codex +1 ★ 587repo stars brainstorm brainstorm guides interactive feature planning before touching code. Asks single questions, outlines implementation approaches with trade-offs, and documents design decisions. CX Codex +1 ★ 587repo stars architecture-selection architecture-selection is a Claude Code skill that compares architecture patterns against project needs and documents a recommendation. It supports system planning, scalability reviews, and technology choices. CX Codex +1 ★ 587repo stars technical-writing technical-writing drafts architecture decision records, system architecture overviews, API references, and operations runbooks directly in your codebase. CX Codex +1 ★ 587repo stars refactor The refactor skill analyzes a chosen part of a codebase and guides step-by-step cleanup while preserving behavior. Use it to improve readability without changing business logic. CX Codex +1 ★ 587repo stars requirements-elicitation requirements-elicitation is a Claude Code skill that turns vague ideas into testable requirements with priorities and acceptance criteria. CX Codex +1 ★ 587repo stars pattern-detection pattern-detection finds naming conventions, architectural layers, and test styles across files. Keeps generated code aligned with repository habits. CX Codex +1 ★ 587repo stars

Project sponsors

Companies that keep this analytics open