Builders that reproduce, and the rules that stop them being cancer.
node colony.mjs run the colony
node speak.mjs "make the covers" tell it in a sentence
node prove.mjs check the bounds still hold
Cover images write to out/ next to this tree, because of one decision
you made. That is the whole pitch.
A cell carries DNA, does one tiny job, and may make copies of itself. Nothing about that is new or clever — it is a fork bomb with better manners. What makes it useful is what it is not allowed to do.
DNA { gene, arg, telomere, lineage, strain } plain JSON, copyable
gene check() observe. changes nothing. -> {ok, detail}
needs() which human decision is missing, if any
work() do the one job
split() propose daughters
A gene with work is a worker: does the job, verifies it, stops.
A gene with split is a progenitor: does nothing itself, and is judged on
whether its children between them actually finished — checked by re-running the
parent's own check afterwards.
A cell may not divide until its work is verified. The check must have failed before and passed after. A cell that cannot show both halves arrests: it reports, it dies, it has no children.
That is the difference between a colony and a tumour. Not proliferation — proliferation is the point. The difference is a cell that keeps dividing after the part that says no has broken.
Four more limits, all borrowed rather than invented:
| limit | from | what it stops |
|---|---|---|
| telomere | Hayflick | depth. Carried in the DNA, shortened by the engine, never settable by a gene |
| census cap | nutrient limit | population, regardless of branching factor |
| contact inhibition | epithelium | two lineages writing the same file |
| apoptosis | programmed death | a thrown error leaving children behind |
node prove.mjs runs thirteen adversarial genes that try to break each of these
on purpose. It exits non-zero if any bound gives.
Compute is not scarce. The machine is paid for and the work is deterministic. The scarce thing is a person deciding something — slow to produce, finite in a day, and the only input the colony cannot make for itself.
So the scoreboard is not jobs done. It is jobs done per decision eaten. A colony that finishes forty jobs and asks forty questions has achieved nothing; it converted a person's fuel one-for-one into work they could have done themselves, with extra steps and a nicer report.
Three things follow, and all three are enforced rather than recommended:
- Nothing interrupts. A cell needing a decision goes dormant and the colony hands over every pending question at once. Twelve questions batched cost one act of attention. Twelve questions asked twelve times cost twelve, and that is how software eats a life.
- Answers are inherited. A decision joins the
strainand every descendant carries it. Spent fuel is stored, not burned. - Answers decay. Each has a half-life. Past it, the colony keeps using the old answer and quietly offers it for confirmation — never blocking, because confirming is cheaper than deciding and neither is free.
The lifetime cost in attention is therefore questions × (life ÷ half-life).
Finite, in units of you.
The check is the Y chromosome.
The Y cannot recombine — it has no partner to repair from — so it decays. Muller's ratchet: deleterious mutations accumulate one irreversible click at a time. It has lost about 97% of its ancestral genes. It survives by being small, carrying one decisive gene, and repairing from palindromes inside itself.
A check is in exactly that position, and pays exactly that price:
- It must not recombine with what it judges. Let the thing being graded write its own grader and it drifts toward graders that pass — with no intent to deceive, which is what makes it dangerous. In a cell that job belongs to p53. p53 is mutated in roughly half of human cancers. The guardian being the most commonly broken part is not a coincidence; it is what gets attacked first.
- So it stays small, because it cannot self-heal.
- And it ratchets one way only. A check may be tightened freely. Loosening one costs a human decision and is recorded — otherwise every locally reasonable relaxation compounds into a suite that passes everything.
Corollary, wired into speak.mjs:
A model may propose a
split. A model may never author acheck.
speak.mjs is not a model and does not pretend to be. The job is not
understanding language — it is picking one of N, where N is how many things the
colony can do. N is small, finite, and known. Infinitely many things can be
said; only N can be meant.
A ladder, cheapest first, with every expensive answer written down so the same sentence lands cheaply forever after:
| rung | handles | cost | built |
|---|---|---|---|
| 0 · unilanguage | covers size=etsy |
free | yes |
| 1 · learned phrase | anything said before | free | yes |
| 2 · stem | pic / pics / picture | free | yes |
| 3 · edit distance | coevrs, guumroad | free | yes |
| 4 · static word vectors | artwork ≈ images | free, offline table | no |
| 5 · ask you | a new phrasing | 1 fuel, kept | yes, --means |
| 6 · ask a model | last resort | money, kept | no |
Rung 0 is the important one. The unilanguage is not a new invention — it is the DNA. English is not built into this system at any level; it is one dictionary pointing at the unilanguage. A Spanish one, an emoji one or a voice one would sit beside it and the engine would not learn a word.
When nothing matches, it says so and logs the sentence to misses.jsonl. That
file is the most valuable thing here — a demand signal in your own words for
what the colony should learn to do next. Because a miss is one of two things:
- a new way of saying a known job →
--means, once, free ever after - a job that does not exist → write a gene. No language handling substitutes for one, and a model asked to cover that gap will confidently pretend instead.
cell.mjs the engine. every limit lives here, none in the genes
colony.mjs run it, report what it cost
speak.mjs sentence -> DNA, the ladder, the miss log
prove.mjs thirteen adversaries. exits non-zero if a bound gives
genome/covers.mjs one real genome: the ChuuMind cover images
render_card.py one protein. draws a card, refuses to draw nothing
decided.json fuel already eaten. delete it and it gets hungry
phrases.json what it has learned to understand
misses.jsonl what it could not
It cannot hold a conversation, and it should not try. It resolves commands into a finite job set. Anything outside that set gets an honest "I don't know" rather than a plausible wrong answer — which is the one thing a system with an infinite output space can never give you.
prove.mjs is not a formal proof. It names no calculus and supplies no
derivation. It is thirteen executable adversarial cases: weaker than a proof,
much stronger than a claim.
Known identities, independent of this engine, re-derived as true:
(a+b)^2 = a^2 + 2*a*b + b^2exp(1) < 31+2+4+8+16 = 31
Nothing else is claimed as settled math here.
And nothing bounds a lying check. A gene whose check always returns ok does no work and reports quiescent forever. It consumes nothing, so it is harmless to the colony — and it is the entire reason the check must never be written by whatever it judges.