Cloudflare Open-Sourced the Security Auditor It Uses on Its Own Code

Most "AI security scanner" projects die at the same place: the model finds something, writes a confident paragraph about it, and you spend the next hour figuring out that the "critical RCE" is a test fixture.
Cloudflare published a skill last week that is built around avoiding exactly that outcome. It is called security-audit, it sits at around 57,000 stars with roughly 10,000 added in the past week, and it is MIT licensed. It is also not a scanner. It is a procedure.
The README is unusually direct about where it came from: this skill seeded the vulnerability-discovery harness described in Cloudflare's own engineering blog post, which later grew into a multi-stage fleet-wide system. The public repo is the single-repo starting point that thing evolved from. That provenance explains the tone. Nobody writes "defense-in-depth gaps are not vulnerabilities" as a rule unless they have been handed a report full of them.
Six phases, one ledger
The workflow runs in a fixed order, and each phase writes artifacts you can inspect.
Phase one is reconnaissance. The agent maps architecture, trust boundaries, input surfaces and prior evidence into architecture.md, and starts a coverage-ledger.json. That ledger is the spine of the whole thing: it is a list of units that need to be covered, and it is validated by a zero-dependency script both after creation and after every later update.
Phase two is coverage-led hunting. Isolated hunters get assigned from the ledger, record what they checked, and coverage critics look for gaps. Phase three hands every unique candidate to a fresh verifier whose job is to disprove it. Phase four writes three verdicts into findings.json and validates against a JSON schema. Phase five has fresh agents re-verify final source claims. Phase six derives the readable reports from the verified records.

The three verdicts are the interesting design
Every finding lands in one of three buckets, and the definitions are strict.
confirmed means a complete source trace plus a bounded observed result. needs_validation means an exact unresolved fact and no severity attached. rejected records a candidate that was disproved.
That middle bucket is the one most tools do not have, and it is the one that makes the output usable. A blocked lead with "we could not execute this because the sandbox was unavailable, and here is the precise question that remains open" is worth more than a fake critical. The skill enforces this mechanically: if you do not have an OS-enforced sandbox, the workflow keeps the lead at needs_validation instead of running target code.
The other rule that matters is organizational rather than technical. The agent that checks a finding is never the agent that found it. Adversarial validation, in the README's words. Anyone who has watched a model rationalize its own earlier claim will understand why this is not optional.
Installing it takes one command, and that is the easy part
npx skills add https://github.com/cloudflare/security-audit-skill --skill security-audit
Add --global for a user-level install. Then you start your coding agent in the repository you want audited and say something like:
security audit this codebase
or
do a security review, output to ~/audits/my-project
The skill activates on matching requests. A direct audit or pen-test ask runs full audit mode; a security question runs a guidance mode unless you ask for artifacts. With no output directory specified, results go to ~/security-audit-skill/<repo-name>/run-<N>, and it will only write inside the target repo if you explicitly choose a directory that version control ignores.
Then comes the requirement nobody reads until it bites. You need a coding agent whose model supports tool use and parallel sub-agents, Node for the validators, and an OS-enforced sandbox that disables external networking, uses a sanitized allowlisted environment, enforces resource limits, and permits writes only to assigned scratch paths.
That last clause is the whole product. Without it the skill still works, but it degrades into a reading exercise, because it will not build, test, fuzz or run anything from the target. For a solo developer on a laptop, standing up that sandbox is a real afternoon of work. For a platform team that already has a container harness, this drops in.
How to scope a run without wasting a day
The skill will happily audit an entire repository, which is the wrong first move. Point it at one service or one directory, and point it at the part of the codebase where an attacker's mistake is most expensive: the request parser, the auth middleware, the file upload path, the thing that talks to a second tenant's data.
Then read the coverage ledger before you read the findings. If the ledger is thin, the findings are thin, and no amount of prose in REPORT.md will fix that. The ledger is the only artifact in the whole workflow that tells you what was not looked at, and "not looked at" is the thing that gets you breached.
Also budget for the second run. The design assumes repeated passes add coverage, and the honest reading of Cloudflare's own numbers is that the first pass gets you about half. If you only ever run it once, you are paying full price for half a result.
What it is actually good at
The file list tells you where the depth is. There are hunting-class documents for memory safety and binaries, for prompt injection and agent/tool handling, for HTTP request framing and auth protocols, for DOM injection and prototype pollution, for supply chain and release signing, for IAM and container and serverless config, for RPC and queues and webhooks, for resource exhaustion, for tenant isolation and data lifecycle, and for desktop/mobile local IPC.
Ten domains, each a separate prompt pack. That is a much more honest structure than a single "you are a security expert" preamble, because it lets the agent load the classes that fit the target instead of hallucinating coverage across all of them.
There is also an explicit answer to the obvious question, which is that one pass is not enough. In Cloudflare's own test runs, a single run found roughly half of the vulnerabilities that repeated runs found in total. So the skill is designed to be additive: later runs read the prior ledger and findings, target gaps, revalidate changed source, and refuse to treat stale or unresolved work as covered.
Where I would push back
Two things.
First, coverage ledgers can become paperwork. A hunter that has to justify every unit it checked will eventually start writing checks that satisfy the ledger rather than the code. The validator scripts prove the JSON is well formed. They cannot prove the hunting was honest.
Second, the six-phase structure is expensive. Six phases, isolated hunters, fresh verifiers, independent re-verification of every material replacement — on a mid-sized repo that is a lot of tokens and a lot of wall clock. The README is upfront that severity should come from likelihood times impact rather than checklist deviation, but the process itself is a checklist, and running it on a 40,000-line service before a release is not realistic.
My read: use it the way Cloudflare uses it. Not as a gate you run on every commit, but as a scheduled deep pass on the parts of the system where being wrong is expensive, with the sandbox in place so the findings can actually be observed rather than theorized.
The bar this thing sets is not "does it find bugs". It is "does it refuse to lie about the ones it could not prove". That is a lower bar than it sounds, and almost nothing else in this category clears it.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.