A customer gave me a plugin review skill. I took it apart.
In August, Hakan (hakan_nedim on our Discord), who has been a customer since 2024 and runs several WooCommerce computer stores, sent me a Claude skill for reviewing WordPress plugins. It was a single file, 1,247 lines long, and it described itself as a portable edition of an agency’s in-house review skill, with the agency’s own servers and repositories taken out.
The next day I split it into its component parts, and a week later the split version reviewed Super Speedy Imports and found real security problems, which is the only test that matters. I’ve now published the security part on GitHub so you can run it on your own plugins: superspeedyplugins/skills, in the plugin-security-review folder.
What it found
These are three of the security findings it confirmed in Super Speedy Imports, and the fixes are in the public changelog for version 2.88:
- Executable filenames from image URLs. A supplier image URL ending in
/image.phpthat returned a real PNG was saved into uploads asimage.php. On a server that runs PHP from the uploads folder, that’s a file someone else chose the name of, sitting where PHP will execute it. - PHP objects from supplier data. Supplier metadata could be unserialised into PHP objects during WooCommerce imports, which is the classic starting point for object injection.
- TLS verification switched off on a loopback. When the plugin’s scheduler falls back to calling its own REST route, it sent a short-lived token with certificate verification disabled, and that token was the route’s only protection.
The review doesn’t report a finding without a trace behind it: where the value comes from, who controls it, what checks it passes through, and where it ends up. Each of these came with one, and the follow-up review re-tested every fix on a test site.
Why split it
The full review was slow and expensive to run, and once I’d fixed something, the only way to check the fix was to run all twelve reviews again. Split up, I run the one review I need: fix a permissions bug, rerun the security review, done.
The original asked one model, in one context, to do twelve different kinds of review over every file in the plugin. Split up, each review gets a clean context and one job, several can run at the same time, and all of them work from the same evidence about the same revision of the code, so their findings can be merged rather than argued about.
The parts
I split the original into one shared foundation, twelve specialist reviews, and a final step that merges them.
The foundation: an evidence bundle. Before any reviewing, one pass reads the whole plugin and writes down facts, not opinions, tied to the exact revision of the code (a fingerprint of every file, plus the git commit). If the code changes, the evidence is out of date and a check refuses to let a review start on it. The bundle holds:
- A map of the plugin’s features and surfaces: the screens, routes, jobs and integrations, named the way a user would name them, so every finding can say which feature it belongs to.
- Every entry point: AJAX actions, REST routes and their permission callbacks, forms, shortcodes and blocks, cron and Action Scheduler jobs, WP-CLI commands, webhooks, activation and uninstall.
- Every input and where it ends up: each read of
$_GET,$_POST, cookies, uploads and request bodies, followed to its database writes, SQL, HTML output, redirects and file operations. - Every hook the plugin registers, including filters with a branch that forgets to return a value.
- Every write: options, meta, custom tables, transients and files, with what triggers each one and whether two requests at once can corrupt it.
- Every output, and whether its escaping matches where it’s printed.
- What loads on every request, and in which contexts (front end, admin, AJAX, REST, cron, CLI), so heavy code that runs where it can never be used shows up.
- Every dependency and every remote host the plugin talks to.
- Every path that moves money or marks an order as paid, when the plugin touches payments.
The twelve specialist reviews, each run in its own clean context against the same evidence:
- Security. Source-to-sink tracing of every input, with a coverage ledger covering authorisation, SQL injection, XSS, SSRF, file uploads and path traversal, code execution and unserialisation, XML parsing, secrets and data exposure, business logic and replay, and dependencies.
- Performance and cache safety. Query growth, boot cost, assets, scheduled work, and whether anything private can end up in a shared page cache.
- Logic. Calculations, state changes, concurrency and idempotency, with worked examples.
- WooCommerce compatibility. HPOS, the block checkout and Store API, hooks, templates and Action Scheduler, against the versions actually installed. Only when the plugin uses WooCommerce.
- Architecture. How hooks are wired, the plugin’s lifecycle, error visibility and maintainability.
- WordPress coding standards. Syntax, WPCS, PHP compatibility and static analysis, with every tool finding checked by hand.
- Internationalisation. Strings in PHP and JavaScript, text domains, placeholders and the translation catalogue.
- Accessibility. WCAG 2.2 AA across templates, generated markup, styles and interactions.
- Mobile and right-to-left layouts. Responsive behaviour, touch targets and logical CSS.
- wordpress.org compliance. The exact release ZIP checked against the directory’s rules.
- User experience. Admin navigation, how clear the settings are, feedback, and the documentation.
- Removability. What deactivating and uninstalling leave behind, including scheduled jobs and data the plugin no longer needs.
The merge. A final step reads the twelve reports, merges findings that share a root cause (one missing permission check can be a security, WooCommerce and logic finding at once), re-reads the code for every finding it accepts, and groups the fixes by feature so you get a work plan, not a pile of reports. Any Critical finding means “do not deploy”.
Two rules run through all of it, and they’re the parts I’d keep if you threw the rest away:
- Grep finds candidates, reading decides. Nothing is reported, or ruled out, from search results alone.
- A finding needs a complete path. Who sends the value, what checks it passes, where it lands and what happens. Anything short of that is recorded as unverified and costs the plugin nothing.
I ran it on my own plugin first. The full review of Super Speedy Imports 2.88.27 scored 68.1 out of 100. Security came out at 100 once those fixes were in. Accessibility, translation, coding standards and removability scored 40 each, so there’s work to do.
Running the security review on your plugin
Copy the plugin-security-review folder into ~/.claude/skills/ (or .claude/skills/ inside the plugin’s repository), open Claude Code in the plugin folder and ask for a security review. It needs git and Node.js; a local test site lets it confirm findings at runtime rather than only reading the code (the parallel-dev skill in the same repository makes one in a few seconds).
A few things to know before you do:
- It’s slow and it’s thorough. It reads every first-party file and traces every input. On a large plugin, expect it to take a long time and use a lot of tokens. Don’t run it on every commit.
- Run it in a fresh session. If the same conversation wrote the code, the model reviews its own assumptions. The skill tells it to hand the review to a clean agent.
- The report stays out of git. It’s written to
.code-reviews/inside the plugin and excluded locally, because a list of your plugin’s weaknesses doesn’t belong in a public repository. - Reproduce before you fix. Treat each confirmed finding as a claim until you’ve seen it happen on a test site, then write the test that fails, then fix it.
Summary
- Hakan sent me a 1,247-line review skill. Split into parts, it found real security holes in Super Speedy Imports, all fixed in 2.88.
- It now runs as one evidence-gathering pass and twelve focused reviews that all work from the same evidence, then a merge that turns their findings into one work plan.
- The security review is free on GitHub: github.com/superspeedyplugins/skills.
Thanks, Hakan!
Comments