CANONIC: Governance Is Compilation
The paper introduces CANONIC, a governance framework that applies compiler-theory principles to create an auditable evidence ledger for AI-generated content, arguing that while structural admission cannot algorithmically filter out "slop," it ensures every claim is anchored to verifiable definitions and commits for end-to-end reproducibility.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
The Big Problem: The "Slop" Flood
Imagine a factory that can print books faster than anyone can read them. In 2025, this factory (AI) started churning out so much text that it created a new problem: "Slop."
"Slop" isn't just bad writing; it's text that looks perfect, sounds smart, and flows beautifully, but has no connection to reality. It's like a chef who can cook a delicious-looking meal in seconds, but the ingredients are made of plastic. If you eat it, you get sick, but you can't tell it's fake just by looking at the plate.
The paper argues that we can't fix this by hiring more people to read the books (human review) or by building better lie detectors (AI detection). Why? Because the fake books look exactly like the real ones. The factory is too fast, and the "fake" books are too convincing.
The Solution: The "Compiler" Gate
The author, Dexter Hadley, proposes a radical shift. Instead of trying to judge if a book is true (which is hard), we should judge if the book is structurally valid (which is easy).
He calls this Governance as Compilation.
Think of a computer program. Before a program runs, a "compiler" checks it. The compiler doesn't ask, "Will this program solve the world's problems?" or "Is this code brilliant?" It asks three simple, mechanical questions:
- Did you use a word that exists in the dictionary?
- Did you reference a file that actually exists on the computer?
- Is that file in the folder you said it would be?
If the answer to any of these is "No," the compiler says "Error" and stops the program from running. It doesn't matter if the code is brilliant; if it's structurally broken, it gets rejected.
CANONIC applies this same logic to AI writing. It acts as a "compiler" for text. Before any AI-generated content is allowed into a public library (the "corpus"), it must pass through three gates.
The Three Gates (The "Triad")
For a piece of writing to pass the CANONIC gate, it must be built like a specific type of folder containing three specific files. If any file is missing, the text is rejected immediately.
- The Rulebook (CANON.md): This file says, "Here are the rules for this specific topic." It's the law.
- The Dictionary (VOCAB.md): This file defines every single word used in the Rulebook. You can't use a fancy word unless you've defined it right here. This stops the AI from making up jargon.
- The Description (README.md): This file explains what the project is actually about.
The Analogy: Imagine you are building a house.
- The Dictionary is the list of approved materials (e.g., "Brick" means red clay brick, not red plastic).
- The Rulebook says, "Every wall must be made of Brick."
- The Description says, "This is a house."
If you try to build a wall out of "Red Plastic" without defining "Red Plastic" in your dictionary, the inspector (the compiler) stops you. You can't just say, "Trust me, it's a wall."
The "Evidence Ledger"
The paper introduces a second layer: The Ledger.
Every claim made in the text must be tied to a specific "commit" (a saved version of a file) in a public, unchangeable record (like a Git repository).
- The Claim: "The patient improved."
- The Anchor: "See commit #12345 in the Ledger."
If the writer cannot point to the specific commit that proves the claim, the text is rejected. It's like a court case where you can't just say, "I saw it happen." You have to produce the video tape. If you don't have the tape, the claim doesn't get into the record.
What CANONIC Does (And What It Doesn't)
This is the most important part of the paper. The author is very honest about the limits.
What it DOES:
It guarantees Accountability.
If a piece of text passes the gate, you know for a fact that:
- Every word is defined.
- Every claim points to a specific, unchangeable piece of evidence.
- The rules were followed.
It turns "unverifiable prose" into a "checkable record." Even if the text is wrong, it is now traceable. You can look at the evidence, see where it went wrong, and fix it.
What it DOES NOT DO:
It does not guarantee Truth.
The paper ran a test (a benchmark) to see if this system could filter out "Slop." The result was surprising: It couldn't.
- The Test: They fed the system fake news, real news, and tricky AI-generated lies.
- The Result: The "Compiler" gate let the fake news through if the fake news was well-structured (defined words, fake evidence that looked real, and a clear timeline).
- The Lesson: A machine can check if a sentence is grammatically valid and referenced, but it cannot check if the sentence is true.
The Analogy:
Imagine a security guard at a bank.
- CANONIC is the guard who checks your ID. If your ID is forged but looks perfect, has a photo, and matches the database format, the guard lets you in. The guard ensures you have valid ID, not that you are a good person.
- Truth is decided by the bank manager (the human expert). The manager looks at the ID, sees the person, and decides, "Wait, this person is lying about their bank balance."
The paper argues that we have been trying to make the guard (the algorithm) decide who is lying. The paper says: Stop. The guard's job is just to check the ID. The manager's job is to decide if the story is true.
The "Human-in-the-Loop"
The system is designed so that Humans write the Rules, and AI writes the Content.
- Humans set the "Constitution" (the rules in the CANON.md file).
- AI generates the text.
- The "Compiler" checks if the AI followed the rules.
- If the AI tries to change the rules, it is blocked. Only humans can change the Constitution.
This creates a system where AI can be fast and creative, but it cannot break the law or hide its tracks.
Summary
The paper concludes that we cannot build an algorithm that automatically spots "Slop" (fake or ungrounded AI text) because "Slop" can be made to look structurally perfect.
Instead, we should build a system that forces Accountability.
- Old Way: "Trust me, this AI wrote a true article." (Hard to verify).
- New Way (CANONIC): "Here is the article. Here is the dictionary of words used. Here is the exact file where the evidence lives. Here is the rulebook it followed. You can check it all yourself."
The system doesn't stop the lies; it just makes sure that if a lie is told, it leaves a clear, unchangeable trail of evidence so that human experts can find it and call it out. It turns the "black box" of AI into a "glass box" where everything is visible and checkable.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.