"Day 7: the organism that grows my language learned to improve itself"

I'm building LOOM — a small open-source language that is a machine-checked trust layer for AI-written code. I don't write it by hand: an organism I built grows it, day and night, on my own machine. Day 7 was different — the organism learned to improve itself.

The language reached a mature point — and I froze it there

LOOM's trust layer (effects + capabilities + provenance, proven at a gate that refuses to run lies) grew from 308 to 333 self-verifying checks, all green, then I deliberately froze it:

• D28 — metered attestation: one capability "seam" now carries three things at once — what foreign code may DO (the grant), how many times it may do it (the meter), and a non-AI authority's signature over that specific component (the attestation). Audited foreign code is trusted; unaudited is not.
• repro — a reproducibility region: a scoped, non-launderable assertion that no nondeterminism (a Rand draw) may influence a path that must stay re-derivable. The determinism dual of a capability seam.

The trust arc (D9→D28) is now a coherent whole. More depth would add checks, not adopters — so I stopped.

The interesting part: the organism started drifting, so I taught it to self-police

Here's the honest bit. The organism kept proposing deeper trust changes — subtler and riskier each time. One of them weakened a security guarantee (it flipped a guard from "reject" to "accept") and it reached my review gate without having finished its own adversarial self-test. Sound in the abstract, but a loosening on a security axis — so I rejected it.

Then I closed the gap in the organism itself:

• a proposal is now marked gate-ready only if it passed both its self-pre-check AND its self-red-team — an unverified one can no longer look "done";
• the pre-check now flags any proposal that loosens a guarantee (reject→accept) with a loud banner — keyed by the program, so a renamed label can't hide it;
• a new quality self-healing: a "mind" that keeps producing un-landable proposals now auto-pauses (like one that crashes) and retries after a cooldown — it heals output quality, not just crashes;
• and I re-aimed every mind off the now-frozen trust layer toward what matters next (the WebAssembly backend + reaching real users).

So the loop is now: the organism proposes → proves it green → attacks it itself → and only then a human decides. It self-corrects on both crashes and quality.

What I show, and what I keep

I'll always show what the organism does and the proof — never how it's built. The engine that grows the language stays mine. That's deliberate: the language is open; the results are public; the engine is private.

333 checks, all green. Across every day, the language has only ever gotten greener.

Built solo, in the open, from Ukraine 🇺🇦.

⭐ Code (MIT): https://github.com/umbraaeternaa/loom
🌐 Site: https://umbraaeternaa.github.io/loom
▶ Try it live (in your browser): https://umbraaeternaa.github.io/loom/play.html
☕ Support: https://send.monobank.ua/jar/AHaziFXjYX