Open-source project
cloudflare/security-audit-skill avatar
cloudflare/security-audit-skill

cloudflare/security-audit-skill: a six-phase audit skill for coding agents

A coding-agent skill for multi-phase security audits with independently verified, machine-readable findings

73,059 stars4,893 forksJavaScriptMIT

At a glance

What is it?
Cloudflare's MIT-licensed skill turns a coding agent into a multi-phase security auditor with adversarial validation and schema-checked findings. It is a workflow, not a scanner, and it assumes you can sandbox target code.
Who is it for?
Adopt it if you already run a tool-using coding agent with parallel sub-agents and can give target builds and fuzzers an OS-enforced sandbox with networking disabled; the skill's whole value is that adversarial validation and coverage-led hunting only work when hunters are isolated. Skip it if you need a scanner you can point at a binary and walk away from, or if no sandbox exists, because the workflow then parks everything as needs_validation rather than running target code.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 62 days ago.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • cloudflare/security-audit-skill73,059 ★ · +53,083
Star history
Repository2026-09-222026-11-15
cloudflare/security-audit-skill20k73.1k

53,083 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The gap this fills: agent audits that cannot be re-checked

Ask a coding agent to review a repository for vulnerabilities and you get prose. It reads well, it is hard to falsify, and it is nearly impossible to compare against the next run. The skill exists to replace that prose with records: each candidate finding gets a verdict, a source trace, and a place in a JSON file that a validator can accept or reject.

The audience is narrow and worth stating plainly. This is for teams that already run a coding agent with tool use and parallel sub-agents, and that want the agent's security work to produce artifacts rather than an essay. It is not a scanner. There is no binary to point at a target, and no rule set. The README describes it as a coding-agent skill that orchestrates isolated agents through reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting. Six phases, and the output is a set of documents derived from verified records.

Six phases, two validators, and a coverage ledger

Phase 1 maps the target: architecture, trust boundaries, input surfaces, prior evidence, and deterministic coverage, written to architecture.md and coverage-ledger.json. The ledger is the spine of the whole run. Phase 2 assigns isolated hunters to ledger units, records their checks, and uses coverage critics to find gaps.

Phase 3 hands every unique candidate to a fresh verifier whose job is to disprove it. Phase 4 writes confirmed, needs_validation, and rejected records to findings.json and checks them against report-schema.json. Phase 5 has fresh agents verify the final source claims, and any material replacement gets another independent verifier. Phase 6 derives REPORT.md, FINDINGS-DETAIL.md, and NEEDS-VALIDATION.md from the verified records and the ledger.

Two zero-dependency Node scripts gate the run. The parent runs validate-coverage-ledger.cjs after creating the ledger and after each later ledger update, and validate-findings.cjs in Phase 4 and again after every Phase 5 replacement. The verdict vocabulary is deliberately narrow: confirmed requires a complete source trace and a bounded observed result, needs_validation requires an exact unresolved fact and carries no severity, and rejected records a disproved candidate. Severity is not a field you can fill in loosely, because the design principle is likelihood times impact rather than deviation from a checklist.

Installing the skill and running a first audit

The README installs the skill through the Skills CLI. The command below fetches the repository and registers the security-audit skill with your agent; add --global for a user-level install, and run npx skills --help for agent-selection and non-interactive options.

bash
npx skills add https://github.com/cloudflare/security-audit-skill \
  --skill security-audit

Then start your coding agent in, or pointed at, the codebase you want audited and ask in ordinary language. The skill activates when the request matches its trigger, so a direct audit or pen-test request uses full audit mode, while security questions and focused vulnerability work use guidance mode unless you ask for report artifacts.

code
security audit this codebase

If you want the artifacts somewhere specific, name the directory. In full audit mode an unspecified output directory defaults to ~/security-audit-skill/<repo-name>/run-<N>, and the workflow writes inside the target repository only when you explicitly select a directory that version control ignores.

code
do a security review, output to ~/audits/my-project

What you should end up with is a run directory containing the ledger, findings.json, and the derived markdown reports. Node.js is required for the two validators. The README also lists a coding agent whose model supports tool use and parallel sub-agents, and an OS-enforced sandbox for target-controlled builds, tests, processes, browsers, emulators, fuzzers, and fixtures.

The sandbox requirement is the real adoption barrier

The requirements section is where this skill stops being a drop-in. It asks for an OS-enforced sandbox that disables external networking, uses a sanitized allowlisted environment, enforces resource limits, and allows writes only to assigned scratch paths. Without those controls, the workflow keeps the lead as needs_validation instead of executing target code.

That is a defensible design choice and an awkward one. A finding that requires running the target stays unresolved unless your environment is already hardened, so teams without sandboxing infrastructure get a run that is heavy on needs_validation records and light on confirmed ones. The skill will not quietly run untrusted code to close the gap, which is the right call and also the reason a first run on a laptop may disappoint.

The second constraint is architectural. The validation model assumes the agent that checks a finding is never the agent that found it, and that material replacements get another independent verifier. If your agent cannot spawn isolated sub-agents in parallel, the phases collapse into one context and the adversarial property disappears. The README does not document a fallback for that case, and it does not document rollback of a run directory either.

Where the attack classes stop

The skills directory ships a long list of hunting-class documents, each aimed at a target shape: memory safety and binary work, AI and LLM prompt injection, HTTP request framing and auth protocols, client-side DOM injection and prototype pollution, supply chain and release, cloud and deployment, RPC and messaging, resource exhaustion, data isolation and lifecycle, desktop and mobile local IPC. That breadth is the point. A hunter is pointed at a ledger unit and a class, not at the whole repository.

Breadth is not completeness. Each document is a set of prompts and rules, and the README does not claim the classes cover every vulnerability category. The design principles also rule out a category of output on purpose: defense-in-depth gaps are not vulnerabilities, so if Layer A prevents the attack, the absence of Layer B becomes a hardening note rather than a finding. Teams that measure audit success by raw finding count will read that as under-reporting. It is the opposite: the skill refuses to inflate the record set, and rejected candidates are kept as disproved rather than deleted.

The README also notes that multiple runs against the same repo are additive, using prior ledgers and findings to target gaps, revalidate changed source, and carry forward current-source evidence without treating stale or unresolved work as covered. The README states that in the project's test runs a single run found roughly half of the vulnerabilities that repeated runs found in total. Treat that as the project's own claim about its test runs, not a number you can expect on your codebase.

How it differs from Semgrep and CodeQL

Semgrep and CodeQL are the obvious comparison, and the difference is not quality but mechanism. Both of those tools match patterns or queries against a codebase deterministically and produce results that are reproducible by construction: the same rule and the same source give the same output, and a false positive is fixed by editing a rule.

The skill inverts that. There are no rules to tune, and the analysis is performed by language models whose reasoning is not reproducible in the same sense. What the skill substitutes for determinism is verification: a separate agent tries to disprove each candidate, a schema constrains what a confirmed record may contain, and validators reject malformed output. The coverage ledger plays the role a rule set plays elsewhere, recording which units were checked so that gaps are visible rather than assumed away.

That makes the two approaches complementary in practice. A rule-based scanner gives you a stable baseline that runs in CI on every commit; this skill gives you a one-off, expensive, reasoning-heavy pass that produces a report with source traces. The README's own framing supports that reading: the skill is the single-repo starting point that Cloudflare's fleet-wide vulnerability discovery harness evolved from, not a replacement for static analysis in a pipeline.

Licence, maintenance, and what a run costs you

The repository is MIT licensed, with the LICENSE file at the top level, so you can use, modify, and redistribute it under those terms. Nothing in the README adds a field-of-use restriction or a contributor agreement requirement. That is the extent of what the repository states; it is not legal advice, and if you redistribute the skill inside a product you should read the licence text itself rather than this summary.

On maintenance, the last push to the default branch was on 2026-09-14, and the repository publishes no releases, so there is no tagged version to pin to and no changelog to diff between runs. Upgrade cost is therefore mostly re-reading the phase documents and the schema when the repository changes, plus re-running the validators, which are zero-dependency Node scripts and need no install step of their own.

The ongoing cost is the run itself. Full audit mode spawns isolated hunters, fresh verifiers, and coverage critics, and it is designed to be repeated because runs are additive. Budget for several runs and a sandbox before you judge the output, and expect the first run to be dominated by needs_validation records if your environment cannot execute target code safely.

Editorial conclusion

Adopt it if you already run a tool-using coding agent with parallel sub-agents and can give target builds and fuzzers an OS-enforced sandbox with networking disabled; the skill's whole value is that adversarial validation and coverage-led hunting only work when hunters are isolated. Skip it if you need a scanner you can point at a binary and walk away from, or if no sandbox exists, because the workflow then parks everything as needs_validation rather than running target code. Before committing, verify that npx skills add resolves the skill in your agent, that Node.js runs validate-coverage-ledger.cjs and validate-findings.cjs unmodified, and that your first full audit writes findings.json that passes the schema.

Frequently asked questions

What does the security-audit skill actually do?

It runs a structured audit in six phases: reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting. Each candidate ends up as confirmed, needs_validation, or rejected in findings.json, and the markdown reports are derived from those verified records.

What skills should I include in a skills audit?

The repository organises hunting classes as separate documents, including memory safety and binary, AI and LLM, web protocol and auth, client-side, supply chain and release, cloud and deployment, RPC and messaging, resource exhaustion, data isolation and lifecycle, and desktop and mobile local IPC. Which ones apply depends on the target shape.

What are the requirements for running the security-audit skill?

The README lists a coding agent with a model that supports tool use and parallel sub-agents, Node.js for the zero-dependency validators, and an OS-enforced sandbox for target-controlled builds, tests, processes, browsers, emulators, fuzzers, and fixtures. Without the sandbox controls, the workflow keeps the lead as needs_validation instead of executing target code.

How do I install the security-audit skill?

Install it with the Skills CLI using npx skills add followed by the repository URL and --skill security-audit, adding --global for a user-level installation. The README points to npx skills --help for agent-selection and non-interactive options.

Where does the security-audit skill write its output?

In full audit mode an unspecified output directory defaults to ~/security-audit-skill/<repo-name>/run-<N>. The workflow writes inside the target repository only when you explicitly select a directory that version control ignores.

Official sources

  1. cloudflare/security-audit-skill on GitHub
  2. Issues
  3. License: MIT
  4. README
Community

Where developers are discussing it

Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.

Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/cloudflare-security-audit-skill.svg)](https://hysenlabs.com/projects/cloudflare-security-audit-skill)

Weekly Top 10 badge

markdown
[![Hysen Labs](https://hysenlabs.com/badge/cloudflare-security-audit-skill.svg?metric=rank)](https://hysenlabs.com/projects/cloudflare-security-audit-skill)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/cloudflare-security-audit-skill.svg)](https://hysenlabs.com/projects/cloudflare-security-audit-skill)

Was this useful?