The manifesto · why this exists

A gate you can't watch fail is not a gate.

Rule of Code exists for one sentence: a quietly disarmed gate is more dangerous than a missing one. A missing gate you know about — you feel the hole. A disarmed gate hands you a green check and your confidence back. And confidence, in the one moment it turns out to be false, is what gets people hurt.

Everything this tool does — the refusal, the coverage count, the detection limits, the dogfood — is downstream of that one sentence.

The argument

Why the disarmed gate is the worse one.

A missing gate is an honest absence. You know the check isn't there, so you stay alert, you review by hand, you don't trust what you haven't verified. The risk is visible, and visible risk gets managed.

A disarmed gate is a dishonest presence. It runs. It prints green. It sits in your CI looking exactly like protection — and it checks less than it claims, or nothing at all. You stop reviewing by hand, because the machine said fine. The team relaxes. The one time the thing it was supposed to catch actually happens, nobody is watching, because everybody believed the light.

The gap between looking checked and being checked is where the failures live.

Below are three real ones — two from teams that use this tool, one of our own. None were caught by reading code. Each looked completely fine right up until someone looked past the green.

Article I · the metric that fed nothing

A dashboard said "alerts configured." The cloud said zero.

What the runbook said

✓ alert policy: unauthorized_401✓ on-call routing: enabled✓ status: monitoredA bot trading real money. Everything ticked.

What was actually deployed

$ gcloud alpha monitoring policies list # filtered to unauthorized_401 … (0 policies) the metric existed. it fed nothing. no policy read it. no alert could fire.

The documentation described a detector that had never been wired. The metric was real — it incremented, it charted, it looked alive — but no alert policy consumed it, so a wall of 401s could climb forever in silence. The bot could have died mid-position and paged no one.

Our law said, plainly, alerts not configured. The team didn't wave it off as a false positive. They went and looked — and found the zero.

▸ caught by the law · the team looked instead of dismissing

Article II · the law that demanded a lie

One of our own laws required the team to claim they'd checked. So they refused.

What the law rewarded

✓ pre-deploy checklist: 90% ticked✓ committed to the repo✓ law: PASSEDGreen — as long as you tick the boxes yourself.

What passing actually required

# to make the law green, a human had to # commit a file asserting checks were done the checklist proved nothing — only that someone ticked it. the law was rewarding the claim, not the work.

The law asked for a checklist, committed to the repository, 90% complete. But a ticked box is not a performed check — it's a promise a human typed. The gate was, in effect, asking the team to assert they'd verified things the tool couldn't see, and grading the assertion.

A consumer read it and refused to lie. They reported the law instead of satisfying it. They were right, and we changed the law — a gate that can only be passed by claiming is worse than no gate, because it manufactures a paper trail of confidence with nothing underneath.

▸ our bug · fixed because someone refused to fake it

Article III · the gate that disarmed itself

A regression shrank our pre-commit set from 122 laws to 27. Quietly.

What every commit showed

✓ pre-commit: passed✓ constitutional check: green✓ 0 violationsGreen for everyone. Nobody looked twice.

What was actually running

# the hook was quietly selecting a subset laws enforced at commit: 27 / 122 95 laws stopped running. nothing turned red. that was the problem. a shrunken audit is a disarmed gate — never PASSED.

It was our own regression. A change narrowed the pre-commit hook to a fraction of the law set, and because the laws that stopped running couldn't fail, everything went green. The absence of red read as health. It wasn't — it was 95 laws no longer watching.

This is the failure the whole product is named after, and we shipped it. It's why the tool now reports how many laws actually executed, gates that number against a liveness floor, and refuses to print compliance the moment the set collapses. We built the floor because we fell through it.

▸ our bug · the reason the liveness floor exists

The doctrine

So the rules are simple, and none of them are about finding more bugs.

They're about never letting the tool claim more than it did. False confidence is the enemy — everything below is a defense against it.

Coverage is reported, never assumed

The audit prints how many laws ran, and gates that count against a floor. Fall below it and it refuses — it will not certify a subset as the whole.

"Unknown" and "not applicable" are different words

A check that couldn't run is not a check that passed. A tool that blurs the two is lying to you politely, and polite lies are the ones you don't catch.

Every law declares what it can't see

Each carries its own detection limits — the sentences stating what it does not claim. Where they're not declared yet, the site says so, with a public counter. Silence is never coverage.

We publish the ones we shipped

The findings above are on the site on purpose. A tool that hides its own failures is precisely the tool you shouldn't trust — so we don't, and this site is audited by its own law on every deploy.

Colophon · how this was made

An AI built this. That’s not the risky part.

Rule of Code — the tool, its 169 laws, and the site you are reading — was built with Claude Code. Not assisted: built. AI agents wrote the detectors, the design system, these pages. Without Claude Code, none of this would exist.

Which raises exactly the question this product answers: why would you trust an AI-written codebase? You wouldn’t. You’d verify it. Every line the agents wrote had to pass the same audit you’ve watched refuse throughout this site — and it refused them, too: three disarmed checkers, a too-greedy regex, a too-short describe, a mis-named branch. All caught. All published on the wall, by name.

The AI wrote every line.
The constitution didn’t care.

A gate that binds humans and machines alike is the only kind that survives the era we’re in — where most code will be written by something that optimizes for green.

the tool that built this · shown as it runs

$ claudeClaude Code Anthropic’s agentic coding CLI. Every law, page and gate in this project passed through it — and back through the audit it was building.

Marks & rights: “Claude Code” and “Claude” are trademarks of Anthropic, PBC — named here factually as the tool used; no affiliation or endorsement implied. The official logomark is not reproduced: Anthropic’s trademark guidelines require prior approval and forbid altered renderings, so the slot above holds a plain typographic asterisk until permission is granted (requested via marketing@anthropic.com). Same standard as our consumer list: we only show what we’re allowed to show.

receipts the gate vs its own builders — on the wall proof the AI-built site passes its own audit — live your turn the prompt that binds your agent the same way

So when it hasn't checked, it says so — and exits non-zero.

That's the whole product. Not more rules. A tool that refuses to hand you a confidence it didn't earn.

Start in five minutes →Read the 169 laws

Pass every applicable law and it prints a unicorn. You cannot fake that either.