The rule that looks careful
"Either an admin, or inserting yourself" reads as diligence. In practice, any account that knew a company's id could join it as an admin. The isolation test found it the day it was written.
Five skills that audit what the AI wrote with tools, proof and a verdict. They find what reading lets through: the access rule that looks careful, the button that does nothing, the 2 pixels users feel and can't name.
AI-generated code compiles, runs and looks well written. The defect that takes a product down is rarely in what looks wrong. It is in what looks right. These are real cases the skills caught after reading-based review had let them through.
"Either an admin, or inserting yourself" reads as diligence. In practice, any account that knew a company's id could join it as an admin. The isolation test found it the day it was written.
One accent apart. The if exists swallows the error, the old rule keeps working and adds to the new one. Each file, read alone, is correct. The ledger enumerates table by operation and puts the two side by side.
In a screenshot, the sign-in screen is done. Operated for real, the main button ignored an empty submit: no request, no message, no required field. It only shows up for whoever clicks and watches the network.
Four corner radii in the same app, two of them almost equal. Ten font sizes competing for body text between 8 and 18px. The interface feels "a bit amateur" and nobody can say why. Measurement can.
Asking an AI to "review the code" fails in two opposite ways: it produces noise that teaches you to ignore the report, or it produces confidence nobody earned. All five skills follow the same method, designed against both failures.
What a deterministic scanner finds, it finds better, cheaper and without hallucinating. Reading is reserved for where tools can't reach: authorization, isolation, business logic.
A typical review asks "look for secrets" and misses the git-ignored .env, which is where the real key lives.
"Found nothing" and "didn't look" are different sentences. Every report carries a map of what was covered and what was left out, unit by unit.
A typical review says "no vulnerable dependencies" with the scanner not installed.
Every finding survives an explicit attempt to take it down. Critical and high findings go through a verifier that didn't write them.
A typical review lists thirty problems, twenty are noise, and you throw out the real one too.
A count by severity and one decision: ship or don't. A 0 to 100 score isn't reproducible and hides the one failure that matters.
A typical review gives "92/100" to an app with the database admin key inside the browser code.
Each skill answers a question a product owner has to answer before shipping. All of them start with tools, end in a verdict and state what they didn't cover.
An in-depth security audit. It runs the scanners before any reading, enumerates every surface unit in the code and only reports what survived refutation.
Ends in a count by severity and ship or don't ship, with open items and the check the owner runs.
Operates the real app, task by task: clicks, types, completes the flow, forces the forgotten states and instruments the console, network and controls.
Ends in a verdict by blockers, never a UX score.
Audits MCP servers, skills and agents before you install a third-party one or publish your own. Extracts the surface without running the server.
Ends in install or don't install, or publish or don't publish.
No design system needed. It measures real geometry in the browser, infers the scale the app already uses and points to where it contradicts itself.
Ends in the inferred scale and its deviations, and can generate tokens for the next skill.
Scans what is actually painted, screen by screen, compares it to the tokens and applies the swaps with verification. For when the design system arrived after the screens.
Ends in compliant or not compliant, with the states and screens it didn't scan.
The order is the defense. What tools find comes before reading, and nothing reaches the report without passing adversarial verification.
Names who attacks, which boundary is crossed, which control fails and what they get, with a path in the code. Only this gets a severity.
A visible layer blocks it. It is recorded with the proof and never shows up as a finding.
A fact outside the repository is missing. It names the exact check the owner runs and gets no severity.
The ledger is the difference between "I looked at the access rules" and "I looked at these 100 rules, at these commits". The next audit inherits what didn't change and reopens what did, by git diff. Example excerpt:
| id | unit | source | state | note |
|---|---|---|---|---|
| pol-7cb00 | members · INSERT · "admin invites" | 0084:24 | covered | admin only; the isolation test covers it |
| pol-99dcd | members · UPDATE · "cada um edita o próprio cadastro" | 0001:152 | planned | near-homonym of 0065: a failed replacement? |
| pol-5be21 | credentials · DELETE · "cleanup" | live catalog | pending | production only, in no migration |
| dee-02477 | app:// (URL scheme) | Info.plist | out of scope | platform-only round |
No average to dilute it. One critical finding is enough to decide, and the report says so in three words. Example header:
Ledger: 304 units, 0 planned · pending validation: 1
| When | Prompt review | v12x skill |
|---|---|---|
| who finds it | The model's memory, which varies every run | A deterministic scanner first, reading only where it can't reach |
| what it didn't see | Disappears from the text | A coverage map and ledger, every unit with a state |
| false positives | Make it into the report | Die in refutation; critical and high by an independent verifier |
| "I don't know" | Becomes a guess or a finding | Pending validation, with the check that settles it |
| the output | A long list, sometimes a score | A count by severity and a decision to ship |
| afterwards | The report goes stale | The finding becomes a CI test and the next audit inherits by diff |
| when fixing | May refactor what it shouldn't | Guards: it audits and records, it doesn't rewrite |
Code changes the next day. What brings a product close to "no gaps" is closing the loop, which is why every skill leaves behind something that runs on its own.
In a real app, the cross-company isolation test had been passing for six weeks. While proving a fix, we found that its "the database must refuse" checks never failed: the test swallowed its own error. The rule that came out of it is now in the skill: every refusal test has to be seen failing once, against a database with the hole open, before it counts as proof.
In the same round, the ledger had flagged a hole as a production issue. The live catalog showed it only existed in the database CI builds. That correction became a rule too: a database finding is only confirmed after checking it against production, and the report says which database it belongs to.
Once installed, each skill triggers on its own when you ask for an audit, or by name. Open source, MIT license.