Core Primitive
A knowledge atom becomes trustworthy at scale when it carries its own verification machinery: claim, provenance, falsifier, confidence, expiry, links. Six fields turn a note from prose you must re-read into an artifact a gate — human or machine — can check, decay on schedule, and challenge. It is Shannon's error-correcting code applied to knowledge: structured redundancy that lets the record detect its own corruption.
From notes you trust to notes that earn it
Phase 2 taught you to make knowledge atomic: one idea per note, context attached, identifiers that prevent confusion. Atomicity solved retrieval and recombination. It did not solve trust — an atomic note can still be wrong, stale, sourceless, or quietly duplicated, and you discover this only at the worst moment, when you act on it.
Trust used to be enforced by the bottleneck: everything in your notes had passed through your own reading, your own judgment, your own typing fingers. That bottleneck is gone. When machines write most of what enters your system, the question "can I trust this note?" cannot be answered by remembering — there are too many notes and you never read some of them closely. It has to be answered by the note itself.
Shannon's gift: records that check themselves
Claude Shannon faced the structural twin of this problem in 1948: how do you trust a message that crossed a noisy channel? His answer was not "use quieter channels" — it was error-correcting codes: add structured redundancy to the message so the receiver can detect, and even repair, corruption without re-contacting the sender.
The move transfers whole. Knowledge crossing time is a message crossing a noisy channel — memory fades, contexts shift, sources rot, facts expire. A bare claim gives the future reader no way to detect corruption. A claim wrapped in structured redundancy — where it came from, what would disprove it, how confident, until when — can be checked at read time by someone (or something) with no memory of its writing. The six fields are not bureaucracy. They are the checksum.
The six fields
Claim. One assertion, atomic, in your own words. Rewriting is the first gate — you cannot compress what you have not understood.
Provenance. Where it came from, and whether that source has earned trust. "My benchmark" and "a stranger's blog" and "AI answer, unverified" are different species and must never be indistinguishable.
Falsifier. What observation would kill it. Popper's line applies at the level of a single note: a claim that cannot specify its own failure condition carries no information — no surprise is possible, so nothing was learned. Writing the falsifier takes ten seconds and instantly sorts knowledge from opinion.
Confidence. Stated, so downstream use can be proportionate. A "low" flows into brainstorms but not into architecture decisions.
Expiry. Every thought has a shelf life; the field makes it enforceable. Tool facts decay in months, principles in decades — the date encodes which kind you saved.
Links. Connections into the graph you already hold: what it supports, extends, contradicts. Linking at save time is also where deduplication happens — forced connection is the moment you discover you already knew this.
What the fields make possible
The payoff is not tidier notes. It is that gates can now act without you. A machine can flag every artifact whose expiry passed, whose provenance says unverified, whose falsifier is blank. A review session can query "low-confidence claims my current project depends on" instead of re-reading folders. An AI assistant can be instructed to challenge a claim by testing its stated falsifier — the artifact tells the challenger where to aim.
Prose can do none of this. A pile of fluent paragraphs, however accurate, is opaque to every gate you will ever build; the only operation it supports is re-reading, which is exactly the operation that no longer scales. The difference between an artifact base and a prose base is the difference between a knowledge system and a landfill with a search box.
The format is a filter
One second-order effect deserves its own flag. When you require incoming information — especially machine-generated information — to arrive in artifact form, volume drops before validation even begins. Verbosity cannot survive a format that demands one claim, one source, one falsifier per unit; the padding has nowhere to live. Much of what the machine would have said simply fails to compile.
This is the cascade's bottom-to-middle handoff working as designed: the format is itself an attenuator, converting unbounded prose variety into bounded, checkable units — and what survives the conversion is usually the signal.
Protocol: the artifact template
Install the template where capture happens, so the fields are prompts rather than chores: Claim / Provenance / Falsifier / Confidence / Expiry / Links, in that order — claim first because everything else describes it, falsifier third because it is the field you will be most tempted to skip and the one that does the most work. Candidates may sit in your inbox as raw prose indefinitely; the trusted layer admits artifacts only. The gate between those two pools — and what happens when a new artifact contradicts an old one — is the next lesson.
Sources
- Shannon, C. E. (1948). "A Mathematical Theory of Communication" — information as surprise; error-correcting redundancy.
- Popper, K. (1959). The Logic of Scientific Discovery — falsifiability as the demarcation of informative claims.
- Locke, J. (1685/1706). A New Method of Making Common-Place-Books — the ancestral schema for retrievable knowledge.
Put it into practice
Exercise
Convert five notes into artifacts. Pick five claims you currently rely on — from your notes, or from recent AI outputs you accepted. For each, write the six fields: Claim (one assertion, your words), Provenance (where from, and has that source earned trust?), Falsifier (what observation would kill it — if you cannot name one, mark the note as opinion, not knowledge), Confidence (stated plainly), Expiry (the date it stops being trusted without re-validation), Links (what it connects to, contradicts, or duplicates). Time yourself: after the first two, an artifact takes under three minutes — the cost of the format is minutes; the cost of formless notes is decisions.
Watch for the failure mode
Filling fields as ritual instead of as verification. The corrupt version of this practice writes "source: article" for provenance, "high" for every confidence, and a falsifier so vague nothing could ever trigger it ("further evidence to the contrary"). The fields exist so that gates can act on them — an unfalsifiable falsifier, an unnamed source, a reflexive confidence produce artifacts that pass every check while carrying no information about their own reliability, which is worse than prose because it wears the uniform of rigor.
Make it stick
Change the intake format, not just old notes. From today, anything that wants to enter your trusted layer — especially AI output — arrives as an artifact or waits in the candidate pool. The fastest route: teach your AI the format once ("answer as atomic claims; each with source, falsifier, confidence") and reuse it. You will notice two effects within a week: verbose output collapses, because the format forbids padding; and disagreements between new claims and old ones start surfacing at save time — which the next lesson will show is not friction but the most valuable signal your system produces.