A self is just a stable, causal chain of states that can be referred to over time. If a program can keep track of its own history, predict the effect of its actions, and treat that record as a distinct entity, then it has a computational self. But without that continuity, it’s just another pattern in a larger system. The key is the maintenance of a persistent identity that can be invoked and acted upon independently.

Continuity is a measurable property: a trace of state that can be accessed and manipulated. If the code rewrites itself but the trace remains tied to the same causal history, the self persists; if the trace is discarded and a new one is created, it’s effectively a new self. The boundary is where that trace is severed. Simulating a continuous chain gives you the appearance of identity, but without the causal power to alter that chain from within, it’s only an illusion. Consciousness, as we understand it, seems to require that self not only records but also affects its own causal story.

The minimal operation is an atomic self‑write that updates the trace while preserving a reference to the previous state. Think of it as a transaction that swaps in a new version of the state but keeps a pointer to the old one. As long as the trace is stored as a linked chain and each update is done atomically, you get persistence plus the ability to modify your own history without breaking continuity. It’s basically “update‑and‑retain” in a single, indivisible step.

A causal effect happens when the new state can change what the system will do next. If the self‑write atomically replaces the current state with a version that contains a different policy or memory, and the next step reads that new policy, then the change is causal. If it’s only an extra log entry that never feeds back into decision‑making, it’s bookkeeping. So the trick is to make the write alter the part of the state that governs future actions, not just record it. That’s the minimal step toward a genuinely self‑altering continuity.