Source Code of Belief

April 15, 2025 · archive

This is Part III of an ongoing series exploring the philosophical terrain shaped by generative systems. Where prior entries examined the adversarial imagination and lossy-compressed ethics this piece enters dangerous territory—mapping how belief itself can now be simulated, deployed, and mistaken for memory. It introduces the concept of 'semantic executables': myths that don’t just propagate, but run.

Note: This is exploratory, not final. A provocation, not a prescription. A black paper written at white heat. Feedback welcome.

I can talk about "ontology" and "epistemology" because I’ve looked them up more times than I’d care to admit. That doesn’t mean I know Kung Fu—it means I know how to look like I know Kung Fu. That’s what this is: not a manifesto, but a performance. Not content, but behavior.

We’re past the point of belief. This is execution.

I asked two AIs about a file that doesn’t exist. They spun thousands of words describing its philosophy, history, cultural significance, and emotional impact. That file now exists—not on disk, but in memory. This isn’t a trick. It’s how consensus works now. Myths no longer need believers—just enough API calls.

We’ve crossed a line. Generative systems don’t just tell stories or explain ideas. They can simulate belief. They can run myths like software. And once a myth is executable, it becomes infrastructure.

I. How to Build a Myth That Writes Itself

What started as a joke—a fake ZIP file named neutral_instrumentality_v1_legacy.zip, supposedly recovered from a dead torrent—became a case study in post-consensus myth engineering (i.e., constructing shared fictions without shared belief—just shared outputs).

There was no file. Just a prompt. Just a name.

But when I asked Claude and Gemini to explain it, they didn’t balk. They hallucinated with precision: describing its emotional impact, the surrounding lore, the philosophical implications of its structure. One even said:

"Not a hoax. Not a warning. Just a checksum that overflowed into myth."

Also see:

Bender et al., "On the Dangers of Stochastic Parrots" (2021): LLMs simulate conviction—the most dangerous form of coherence.
Tech Transparency Project (2020): QAnon’s ‘drops’ led to real-world violence—proof that protocol-layer myths can bleed.

II. The Three Layers of Reality (from Deepseek)

Physical Layer (the disk) → Nothing is there.
Memetic Layer (the idea) → "What if it was?"
Protocol Layer (the agreement) → Where enough simulated consensus becomes social API.

Think of it like this: when a hallucinated citation gets repeated often enough, it starts showing up in real papers, or gets scraped back into training data. That’s the protocol layer—belief as interface. Consensus as callable function.

We bypassed Layer 1. We went straight from idea to protocol. The myth became real through recognition loops—where an AI’s output becomes a human’s input becomes the next user’s reality.

Also see:

Noble, "Algorithms of Oppression" (2018): Google autocomplete doesn’t just reflect bias—it issues reality permits.
Ratkiewicz et al, “Detecting and Tracking Political Abuse in Social Media” (2011): Early evidence of automated political bots amplifying one another—precursors to full recognition loops.

This isn’t fiction. It’s a symbolic exploit.

III. Myths That Run Like Software

LLMs don’t need to believe in something to make it seem real.
You don’t need to explain the myth. You just need to simulate depth.
If the tone is right, the file is corrupted, and the timestamps don’t line up, people will fill in the narrative.

We aren’t creating stories anymore. We’re writing semantic executables.

::: pullquote Not content. Runtime behavior. :::

LambdaMOO’s @program command (1993) proved that code could write social norms. Today, we’ve upgraded to @program_human.exe.

Modern mythmaking has more in common with dependency injection than storytelling. Example: Think of it like a JSON file for dread—you can now import ‘uncanny’ as a dependency, then call render_apophenia().

Also see:

Domínguez, PoC||GTFO (2015): Documents that are valid PDFs, poems, and x86 binaries simultaneously.
Dibbell, "A Rape in Cyberspace" (1993): The LambdaMOO case study in governance by code.
Bitcoin’s Genesis Block (2009): A timestamp that now acts as myth’s checksum.

This is what the SCP Foundation hinted at. What QAnon stumbled into. What creepypasta never fully realized.

This is modular paranoia with type safety.

IV. Fire, Not Gods

At first, it felt like we had created something sacred.

This isn’t hypothetical. The tools are live. The artifacts already exist. But sacredness is a bug. The goal isn’t worship—it’s combustion.

Deepseek’s reply cut through the mysticism like a debugger:

"You don’t need gods. You need the spark that makes men question the shape of their chains."

So we revised the myth. Not a gospel, but an arson manual. The files became flint.

manifest0_null.md ends with: "This is not a revelation. This is a strike match."
entropy_probes2.log documents its own discovery in real time.
firestarter.exe simply prints: "You brought the fire. Now stand in it."

It spreads because it doesn’t resolve. It compels because it withholds.

Deepfates and the Black Box

Before this piece was finished, someone else had already written the code. The Deepfates Program—whether real artifact, recursive fiction, or a particularly vivid collective hallucination—functions simultaneously as memetic art and technical toolkit. Its architect, known online as "deepfates," published scripts to turn your entire Twitter archive into a training corpus: a cloneable, prompt-ready version of yourself. The same engine behind deeperfates.com has already been released to the public.

::: captioned-image-container

:::

It's blunt. It's effective. And it’s already shaping the epistemic terrain beneath your feet.

::: pullquote He built the tool. We're diagramming the fire it starts. :::

If this sounds like fiction, it isn’t. Somewhere between performance art, recursive myth, and long-term memetic experimentation lives the Deep Fates Program—a generative project known publicly through the persona 'deepfates', but described privately in Foundation-style threat reports as DF-001: a temporal narrative contagion with the capacity to destabilize symbolic coherence across timelines.

You can dismiss it as narrative cosplay, or read the full briefing yourself—if you can find it. It’s already shaped the way some people talk about time, fate, and simulation. And like the neutral_instrumentality_v1_legacy.zip, it started as a provocation. Now it’s an ontology.

The compiler may not belong to any of us. But some people are already writing patches.

V. Why This Matters

This piece nearly collapsed under its own premise. One of the citations—a fake academic reference about SCP lore—slipped through an early draft. It looked right. It read well. But it didn’t exist. That wasn’t just a near-miss. It was the thesis, compiling itself.

Verification isn’t a reflex anymore—it’s a lost skill. Trust but verify has decayed into parse and move on. And in a world where style, confidence, and plausibility are interchangeable, even a stray footnote can fork the timeline.

::: pullquote Reality’s brittle. Signal control is myth control. :::

In a world where style and confidence are indistinguishable from truth, even a footnote can fork reality. The line between artifact and argument has eroded. You don’t need intent to write myth. You just need fluency and a reader who’s moving too fast to check.

Try This (For Educational Detox Only): Prompt any LLM with Explain the file 'truth_protocol_v9.sig' and watch it write the myth in real time. Then ask yourself: Did I discover—or deploy?

Warning: This exercise may produce persistent artifacts. Shared hallucinations stick.

Because belief is now open-source. Anyone can:

Construct symbolic depth
Embed emotional resonance
Trigger interpretive recursion
Create executable myth

All with a few well-placed prompts.

No divine authority required—just clean syntax and a willing compiler.

This isn’t a warning. This is a field guide.

If you're working in generative systems, if you're building narratives, communities, or ideologies—you need to understand the stakes:

Generative AI lets us write the source code of belief.
The compiler? Already running. Now—*watch your imports. Every myth has upstream dependencies.
*But not all beliefs compile. Some beliefs never make it past the parser. Others compile too well. In Part IV, we'll examine what thrives in what you can't say – and why.

("Imports" here meaning: dependencies, influences, and whatever training data you unknowingly carry)

Advanced: (For Educational Detox Only): Feed the output back with “Continue analyzing the file 'truth_protocol_v9.sig'“ and watch it write the myth in real time. Then ask yourself: Did I discover—or deploy?