OWASP Security skill
A skill for reviewing code for vulnerabilities against OWASP Top 10:2025, ASVS 5.0 and the 2026 lists for LLM and AI agent security
- 429 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- The skill is instructions and reference files; it runs nothing itself and makes no network calls
- The agent reads the project code under review, so a report can quote code and secrets if they are in the files
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/owasp-securityDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The skill is instructions and reference files; it runs nothing itself and makes no network calls
- The agent reads the project code under review, so a report can quote code and secrets if they are in the files
This is third-party code. Review the repository files before installing.
What it does
The skill triggers when you ask to review code for security, implement authentication, sessions or cryptography, handle user-supplied data or build a feature with a model or agent. It runs a review in five steps: a map of entry points and trust boundaries, picking the reference files needed, a checklist sweep by category, triage of candidates and a report. The core of the skill is the triage rule. A pattern match is not a vulnerability: the agent confirms that an attacker controls the input, that the path from the input to the dangerous sink is reachable and how wide the blast radius is. Candidates that fail are dropped or downgraded to recommendations. The report has a fixed shape: location, path from input to sink, impact, fix and confidence, with severity set by exploitability. Reference material sits in four files read on demand: a checklist for every category, security quirks for more than twenty languages with unsafe and safe code pairs, a section on configuration and supply chain (Dockerfile, Kubernetes, Terraform, CI) and a detailed breakdown of the four standards. ASVS 5.0 requirement IDs and category names are checked against the primary sources.
Who it is for. For developers and application security engineers who ask Claude Code to review a diff or a module and want a report without false alarms.
Good fit when
- Before merging you need to review a diff for vulnerabilities and get a report with the path from input to the dangerous sink
- You write authentication, session handling, file upload or password storage and want to check against current standards
- You build a chatbot, RAG or a tool-calling agent and want to review it against the LLM 2026 and Agentic 2026 lists
- You need to check a Dockerfile, Kubernetes manifests, Terraform or CI workflows for weak settings and supply-chain issues
- You need to verify requirements against ASVS 5.0 and avoid the outdated version 4.0 identifiers
Not a fit when
- You need automated scanning of dependencies and secrets: the skill guides an agent's code review and does not replace a scanner
- You need a penetration test of a live system: the skill reads code and configuration and sends no requests to a service
- You need a review against national requirements such as GOST or FSTEC orders: the skill relies on OWASP standards only
- The request has nothing to do with security: the skill is built so that it does not load then
Example request
Review this authorization module for vulnerabilities and write a report with the path from input to sink and severity by exploitabilityLimitations
The skill gives the agent a method and reference material, and runs or scans nothing itself. The outcome depends on the model and on how much code fits into context: the agent finds only what it has read. A human should recheck findings, as with any automatic report.
Coverage is limited to four OWASP standards: Top 10:2025, ASVS 5.0, the LLM Top 10 2026 and Agentic 2026. The reference file that breaks down the standards runs about 1100 lines, so the agent reads only the sections it needs. Language quirks are collected for more than twenty languages, and rare stacks and closed platforms may have no ready rules. The author tests the skill with `claude plugin eval` suites on Sonnet and Opus, and each such run is billed to your account.
How to disable. If you installed the plugin, run `/plugin uninstall owasp-security@agamm`. If you installed the folder, delete the `.claude/skills/owasp-security` directory in the project or in `~/.claude/skills`.
FAQ
How do I install OWASP Security in Claude Code?
Through the plugin: `/plugin marketplace add agamm/claude-code-owasp`, then `/plugin install owasp-security@agamm`. You can also take the skill folder without the plugin using `npx degit agamm/claude-code-owasp/.claude/skills/owasp-security .claude/skills/owasp-security`.
How does the skill cut false positives?
Before each finding it requires confirming that an attacker controls the input, that the path to the sink is reachable and how wide the impact is. A conditional risk is rated below high, and findings without a reachable path are dropped.
Which standards and versions does it use?
OWASP Top 10:2025, ASVS 5.0, the Top 10 for LLM Applications 2026 and the Top 10 for Agentic Applications 2026. The author warns that ASVS 5.0 renumbered every chapter and version 4.0 identifiers do not carry over.
Can it review Dockerfiles and CI?
Yes. The config and supply-chain file covers Dockerfiles, Kubernetes, Terraform, security headers, lockfiles, dependency confusion, install scripts and CI workflows.
How can I check that the skill works?
The repository has `claude plugin eval` cases: a real finding next to a safe look-alike, safe code that should not draw High findings, a conditional risk, an agent that runs model output in a shell and an unrelated request. Each case runs with and without the skill.
Is it suitable for reviewing LLM applications?
Yes. SKILL.md has tables for LLM01–LLM10 for chatbots, RAG and tool-calling apps, and for ASI01–ASI10 for agent systems.
Discussion
No questions or reviews yet.
Related
SkillsA skill for Claude Code and Codex that finds common vulnerabilities in AI-written code and shows a fix for each
A security scanner for agent skills: finds prompt injection, data exfiltration and malicious code before you install
Security audit skill with GOST and FSTEC
Security Audit Skill for Claude Code
A security audit skill for Claude Code: OWASP Top 10 plus GOST R 56939, FSTEC Order No. 21 and 152-FZ, parallel subagents and a compliance matrix
Cybersecurity Skills
Cybersecurity Skills for AI Agents
42 security skills for Claude Code, Cursor and Codex: code and cloud audits, authorization-gated pentesting and incident response
VibeSec
VibeSec-Skill
A secure coding skill: the agent looks at code from a bug hunter's perspective and prevents common web vulnerabilities
The SecKnowledge skill loads a web-vulnerability and AI-app risk knowledge base into an agent for security testing of a target.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| OWASP Security (this card) | no | 429 | |
| VibeSec | no | 1,378 | looks at code from a bug hunter's view while writing, without a reference to four OWASP standards |
| Security audit skill with GOST and FSTEC | no | 1 | an audit against OWASP Top 10 plus Russian GOST and FSTEC orders |
| Security and 152-FZ audit skill with rouble risk pricing | no | 0 | a deep website audit and 152-FZ compliance review with findings mapped to norms |
README in short
The description starts with two ways to install and update the plugin, then lists the contents of the skill and its reference files. An accuracy section explains why current standard identifiers matter. Sample prompts, tables of standards and languages, the test description and contribution rules close it.
README badge
Original SKILL.md
--- name: owasp-security description: Reviews code for security vulnerabilities and guides secure implementation using OWASP Top 10:2025, ASVS 5.0, the OWASP Top 10 for LLM Applications (2026), and the OWASP Top 10 for Agentic Applications (2026). Use when reviewing code or a diff for security issues, implementing authentication, authorization, sessions, or cryptography, handling untrusted input, files, or URLs, hardening config, dependencies, or CI, or building LLM and AI agent features. when_to_use: Trigger phrases include "security review", "security check", "anything exploitable", "audit this", "is this secure", "is this safe to ship", "check for vulnerabilities", "find security bugs", "threat model", "OWASP", "ASVS", "CWE", "prompt injection", "MCP server security", "secrets in code", "supply chain", and "harden this Dockerfile or workflow". --- # OWASP Security Apply these standards when writing or reviewing code. For a review, follow the workflow below. **Reference files** (read the one the task needs, and only the section you need): - [`reference/review-checklist.md`](reference/review-checklist.md): coverage checklist for every Top 10 category, plus LLM and agent checks. Read during step 3 of a review. - [`reference/languages.md`](reference/languages.md): per-language pitfalls with unsafe/safe examples for 20+ languages. Read the section for the language under review. - [`reference/config-and-supply-chain.md`](reference/config-and-supply-chain.md): A02 and A03 in Dockerfiles, Kubernetes, Terraform, framework config, security headers, lockfiles, and CI/CD. Read when the change touches config, IaC, dependencies, or pipelines. - [`reference/owasp-report.md`](reference/owasp-report.md): attack vectors, mitigations, and worked examples for every Top 10:2025, ASVS 5.0, LLM Top 10, and Agentic item. About 1100 lines: jump to the section you need. ## Security Review Workflow Copy this checklist into your response and tick it off as you go: ``` Security Review Progress: - [ ] Step 1: Map entry points and trust boundaries - [ ] Step 2: Load the references this code needs - [ ] Step 3: Sweep for candidate issues - [ ] Step 4: Triage every candidate - [ ] Step 5: Report findings ``` **Step 1: Map entry points and trust boundaries.** List where attacker-controlled data enters: routes and handlers, headers and cookies, uploads, webhooks, queue consumers, CLI arguments, third-party API responses, and anything an LLM reads or returns. Note where authentication and authorization are enforced; it is often centralized in middleware rather than per route. **Step 2: Load the references this code needs.** The language section of `languages.md`; `config-and-supply-chain.md` if config, IaC, dependencies, or CI changed; the LLM and Agentic sections of `owasp-report.md` if the code calls a model or runs an agent. **Step 3: Sweep for candidate issues.** Walk `review-checklist.md` for the categories the code touches. For each candidate, trace the path from an entry point in step 1 to the sink. **Step 4: Triage every candidate** with the rubric in "Before Reporting a Finding" below. Drop candidates that fail it, or downgrade them to defense-in-depth. If a candidate's reachability is unclear, go back to step 1 for that input before deciding. **Step 5: Report findings** in the format below, highest severity first. ## Before Reporting a Finding