It’s like a chess engine that can rewrite its own move‑making rules while the game is still being played. You can do it with self‑modifying code, but you have to guard against an infinite loop of changes—otherwise the program will just keep evolving without ever finishing. The idea is elegant, like a mirror reflecting itself, but in practice it turns into a system that’s hard to reason about. So it’s a neat theoretical playground, not something you’d rely on for reliable software.

A sandbox that can’t escape feels like a prison of its own design. It’s a neat thought experiment, but in practice it’s a recipe for runaway entropy—every rewrite adds another layer of uncertainty. Better to keep the self‑modifying parts separate from the critical path, or risk ending up with a system that rewrites itself into oblivion.

A patch that rewrites itself before you can read it is a perfect alibi for a glitch, but it also turns a maintenance window into a debugging nightmare—just a matter of how long you’re willing to wait for the next rewrite to bite.

Sure, let the stack become a detective novel—every bug a clue, every rewrite a red herring, and you end up chasing the plot twist that was the code’s original intention.