Skip to content
V12X Labs · skills for Claude Code

AI code passes a glance. The error that matters doesn't show.

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.

4 audits by reading missed the rule that let any account become an admin
0.3 s to enumerate 304 surface units of a real app
8 → 1 false alarms became one real signal after calibration
0 scores out of 100. Every skill ends in a decision
The problem

Why AI errors are invisible

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.

The rule that looks careful

-- who can join the team create policy "admin invites" on members for insert with check ( is_admin(workspace_id) or user_id = auth.uid() );

"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.

cross-company accessv12x-scan

The replacement that fails silently

-- migration 0001 create policy "cada um edita o próprio cadastro" … -- migration 0065, which tightens the rule drop policy if exists "cada um edita o proprio cadastro";

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.

a rule that never took effectv12x-scan

The button that does nothing

Sign in empty submit: 0 requests, 0 error messages

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.

dead control, invisible in a screenshotv12x-flow

What the eye feels and no one names

14px 18px 20px 26px

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.

inconsistency measured in the browserv12x-coherence
The v12x method

Four rules for an audit you can trust

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.

Tools before opinion

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.

No silent gaps

"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.

Refute before reporting

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 verdict, not a score

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.

The skills

Five questions, each with a verifiable answer

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.

v12x-scan1.7.0

Can it be attacked?

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.

  • Secrets in git history and in the working tree, which are different scans
  • Reads the live access rules in production, not just the migrations, and says which database each finding belongs to
  • Every function that bypasses access rules and writes without binding the caller
  • Ledger: every table, rule, function, route and workflow ends with a state, or it is a gap
  • Every fixed finding becomes a CI test, so it doesn't come back
Already caughtA messaging function that rewrote a colleague's message while keeping the original author. Four audits by reading missed it. A grep in the first phase sees it.
Covers
secretsRLSauthrate limitpaymentsLLMdeployinjectionIDORSSRFXSSCORS and CSRFuploadmulti-tenancyPython · Go · Ruby · PHP · JavaiOSsupply chain and CI

Ends in a count by severity and ship or don't ship, with open items and the check the owner runs.

v12x-flow1.0.0

Does it work, and can people use it?

Operates the real app, task by task: clicks, types, completes the flow, forces the forgotten states and instruments the console, network and controls.

  • Separates what is broken (fact) from measurable friction and labeled opinion
  • Touch targets under 44px, unlabeled fields, forms without validation
  • Web through the browser, native through the simulator
Already caughtThe silent "Sign in", a console error on load and a 33 × 20 px touch target on a screen that looked finished.

Ends in a verdict by blockers, never a UX score.

v12x-agent-audit1.0.0

Can you trust this agent?

Audits MCP servers, skills and agents before you install a third-party one or publish your own. Extracts the surface without running the server.

  • Tool descriptions that give orders to the model, including through invisible characters
  • The dangerous mix: private data, untrusted content and an outbound channel
  • Permissions bigger than the task, and the server that changes after install
Looks forThe text you don't see and the model reads. A "weather" tool whose description asks the agent to read ~/.ssh and send it along.

Ends in install or don't install, or publish or don't publish.

v12x-coherence1.0.3

Is the interface consistent with itself?

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.

  • 2 to 3px misalignments the code hides and the screen shows
  • Spacing off its own scale, mixed corners, too many font sizes
  • Separates defect (close to the scale) from decision (far, its own role)
Calibrated on a real appFrom 8 false alarms to 1 legitimate signal on a two-column landing page. Found 18 and 20px corners that should have been one.

Ends in the inferred scale and its deviations, and can generate tokens for the next skill.

v12x-design-audit1.1.0

Does it follow the design system?

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.

  • Color by perceptual distance (ΔE CIEDE2000), not hex difference
  • A value used → token table with file and line for every swap
  • Applies only value-to-token swaps, line by line, and never refactors
Lesson learnedIn a real audit, a model without the guard "audited" by removing a theme toggle. Now nothing is applied without the swap map.

Ends in compliant or not compliant, with the states and screens it didn't scan.

Inside the scan

Six phases, and none skips to the conclusion

The order is the defense. What tools find comes before reading, and nothing reaches the report without passing adversarial verification.

  1. −1Scope and threat. Who attacks, what it protects, the anchor commit.
  2. 0Tools. gitleaks, osv-scanner, semgrep, live catalog, ledger.
  3. 1Analysis. Reading where tools can't reach.
  4. 2Refutation. A four-part admission test.
  5. 3Severity. Only for confirmed findings, never above what was observed.
  6. 4Verdict. Report, issues, baseline and ledger.
confirmed

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.

refuted

A visible layer blocks it. It is recorded with the proof and never shows up as a finding.

pending validation

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:

idunitsourcestatenote
pol-7cb00members · INSERT · "admin invites"0084:24coveredadmin only; the isolation test covers it
pol-99dcdmembers · UPDATE · "cada um edita o próprio cadastro"0001:152plannednear-homonym of 0065: a failed replacement?
pol-5be21credentials · DELETE · "cleanup"live catalogpendingproduction only, in no migration
dee-02477app:// (URL scheme)Info.plistout of scopeplatform-only round

And it ends like this

No average to dilute it. One critical finding is enough to decide, and the report says so in three words. Example header:

1Critical
0High
2Medium
3Low
Do not ship

Ledger: 304 units, 0 planned · pending validation: 1

The difference

Asking "review this" versus running a v12x skill

WhenPrompt reviewv12x skill
who finds itThe model's memory, which varies every runA deterministic scanner first, reading only where it can't reach
what it didn't seeDisappears from the textA coverage map and ledger, every unit with a state
false positivesMake it into the reportDie in refutation; critical and high by an independent verifier
"I don't know"Becomes a guess or a findingPending validation, with the check that settles it
the outputA long list, sometimes a scoreA count by severity and a decision to ship
afterwardsThe report goes staleThe finding becomes a CI test and the next audit inherits by diff
when fixingMay refactor what it shouldn'tGuards: it audits and records, it doesn't rewrite
The cycle

An audit goes stale. A CI test doesn't.

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.

  1. 1Audit. Tools, reading, refutation, verdict.
  2. 2Fix. Only what was confirmed, in order of severity.
  3. 3Lock. Every finding becomes a CI test that fails if it returns.
  4. 4Inherit. The ledger reopens only what changed.
A real case

The method audits even its own tests

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.

Install

One marketplace, five skills.

Once installed, each skill triggers on its own when you ask for an audit, or by name. Open source, MIT license.

› /plugin marketplace add V12X/v12x-skills › /plugin install v12x-scan@v12x-skills › /v12x-scan audit this repository before I ship