THE STANDARD

On October 31, 2026, we audited every app we make — about 36,600 lines of code across 15 programs. The audit's first job was simply to read the code and ask: does this explain itself? In most programs the answer was yes. In one, the auditors found a single function 1,401 lines long with no internal map at all — nobody could say what its parts were for without reverse-engineering them. That is where undocumented code ends: work no one can safely touch.

def retry(fn, n=3):
    for i in range(n):
        try:
            return fn()
        except Exception:
            if i == n - 1:
                raise
            sleep(2 ** i)

def retry(fn, n=3):
    """Call fn again after a short, growing pause if it fails.

    Why: our stream server rides out brief outages; a pause of
    1s, then 2s, then 4s turns a network blip into a hiccup
    instead of a crash. Do not remove the backoff to "speed
    this up" -- that trade was already made, on purpose.
    """
    for i in range(n):
        try:
            return fn()
        except Exception:
            if i == n - 1:
                raise
            sleep(2 ** i)

The 1,401-line function from Article 1 was rebuilt into 21 small builders, each doing one panel's work, under a 93-line conductor; the longest single function dropped to 125 lines. Then the elegance was measured, not admired: before-and-after screenshots of the running program, at two screen sizes, were pixel-identical, and the backup engine underneath was byte-identical. The structure got better and the behavior did not move a hair. That is the difference between elegant and merely rearranged.

def has_dupes(items):
    found = False
    for i in range(len(items)):
        for j in range(len(items)):
            if i != j and items[i] == items[j]:
                found = True
    return found

def has_dupes(items):
    """True if any value appears twice. One pass, stops early."""
    seen = set()
    for item in items:
        if item in seen:
            return True
        seen.add(item)
    return False

One function, 1,401 lines, 41 percent of the whole app — that single function is what this article forbids, and it is why the October 2026 audit graded exactly one structure in fifteen programs “spaghetti.” The programs the audit rated clean were not cleaner by luck: they were written from the start as small modules with clear jobs, and they stayed that way.

def go():
    global data
    data = open("words.txt").read().split(",")
    for i in range(len(data)):
        data[i] = data[i].strip().upper()
        if data[i] == "":
            data[i] = "EMPTY"
    open("out.txt", "w").write(",".join(data))
    print("done", len(data))

def load_words(path):
    """Read the raw comma-separated words from a file."""
    return open(path).read().split(",")

def clean(words):
    """Trim, set the case, and name the blanks."""
    return [w.strip().upper() or "EMPTY" for w in words]

def save_words(path, words):
    """Write the words back out, comma-separated."""
    open(path, "w").write(",".join(words))

def main():
    words = clean(load_words("words.txt"))
    save_words("out.txt", words)
    print("done", len(words))

Our music player, VOIDAMP, ships with our own radio station built in. On November 1, 2026, its behavior was set into law: the first click of Play plays the station only when the user has chosen nothing else. If the user has loaded a playlist, the playlist plays. If the user has set their own default, their default plays — every single time, until they change it. Our station is a sample, like the little demo clip old players shipped with: proof the speakers work, never the master of the machine. The philosophy, in the words it was ruled with: this is the user's player; ours is only a sample.

Our typing teacher, Keys of the Kingdom, was designed under a first law that allows no exceptions: there are no accounts, no sign-in, no telemetry, no analytics, no update checks, no cloud — not switched off in a settings menu, but not in the program at all; there is no network code to switch off. A learner's profile and progress live in one small, human-readable file on the learner's own computer. If the program never tells us anything about its users, it can never lose, leak, or sell anything about them either.

On October 29, 2026, our backup program AEGIS was put under a standing law: it deletes nothing — no button, no flow, no cleanup routine inside it removes a file. A backup that is interrupted halfway stays on disk, honestly labeled as partial; it is never quietly cleaned away. The one overwrite the program may ever perform is a restore the user explicitly confirms. Within days the rule was generalized to every program we make: no app of ours may ever leave a person asking where their files went.

On October 30, 2026, before an emergency repair window, the house's entire core — its rules, memory, and identity files — was packed into a single archive and copied to a second machine. Only when the archive's SHA-256 fingerprint had been computed on both machines and matched did the work begin. If anything in that window had gone wrong, the way back existed and was proven — not hoped for, proven, in writing, before the first change.

# if this edit is wrong, the old version
# exists only in somebody's memory
nano app.py

# dated backup first, fingerprint recorded:
# the way back is proven before the first keystroke
cp app.py app.py.bak-$(date +%Y%m%d-%H%M%S)
sha256sum app.py >> backups.log
nano app.py

When VOIDAMP's sixth test build was run on its test rig, the rig's position counters advanced exactly as if music were playing — and on that evidence the build looked ready. The claim did not survive contact with the machine itself: checked directly, the running player had no playback-engine process and no connection to the stream. The counters were counting; nothing was playing. A counter is not a sound, a screenshot is not a feature, and a green check mark is not evidence — evidence is evidence.

The automated rig could not reproduce VOIDAMP TEST6's fault at all: on the rig, the stream played clean. On November 1, 2026, the program's architect ran the same build himself, on his own machine, with his own ears — and heard the skipping the rig could not hear, then watched the player wedge after he changed a setting. His verdict was FAIL, and the build was not released: no public download, no next step, no argument. The rig's opinion is on file. It is not the gate. He is.

In October 2026 we built Chinese and Japanese editions of our Bible app from real, published human translations — the only kind this house will ever ship. For the Zulu edition, no lawful, complete text could be sourced: the modern translation is a commercial work we have no rights to, and the public-domain 1883 text survives only as corrupt scanned images that would take a dedicated proofreading project to restore. So the Zulu edition stands reported, in plain words, as BLOCKED — not machine-translated overnight, not quietly shipped in English wearing a Zulu label, not announced as done. The gap is on the record, with its reason. That is what this article costs, and it is worth it.

Pressed to play, VOIDAMP TEST6 answered: “add some music first.” Four words, and every one of them served the program instead of the person — he had pressed Play because he wanted music, and the machine's reply was homework. Ruled, the same night it was seen: that is the wrong behavior. Play now plays — the station, or the user's own choice — because the obvious human meaning of a button is the specification. If a person has to be explained to your program, your program is the bug.

This document is itself the example. Every article in it began as a human ruling, given in plain words, in the middle of real work; the AI's part was to build, to check, and to bring back evidence. And the direction runs both ways at full strength: on October 30, 2026, when the architect gave a single emergency stop, every scheduled job in the house halted — all of them — and not one resumed until his word said resume. An AI that argues with the stop button is not a partner. It is a liability with good vocabulary.