Every instruction to a model is a probability, not a promise. Rules that must always run belong in deterministic automation the model can't skip.
Every instruction you give a model is a probability, not a promise. Even a rule written in capitals in the operating-system file is obeyed, not enforced — the model reads it, weighs it against everything else in context, and usually complies. Usually. For preferences, usually is fine. For the rules where a single miss is expensive — never overwrite this section, always run the check before publishing — usually is a hope wearing a rule costume.
The architectural insight is that one building block in the modern AI stack is deterministic by construction: automation that fires outside the model's loop. A hook that runs on every file-write doesn't ask the model's opinion; the model can't decide to skip it, can't deprioritise it under a long context, can't be talked out of it. That's not a smarter instruction — it's a different category of thing, and knowing the difference is half of making a system reliable.
The design rule that follows is a triage, not a slogan: preferences and style go in context, where the model's judgement applies; knowledge goes in skills; connections go in protocols; and guarantees go in deterministic automation. Walk through your own rules asking one question — what happens on the run where the model ignores this? — and the answer sorts them. If the answer is "mild annoyance," it's context. If the answer is "data loss" or "a privacy leak," it was never a rule at all until it became a hook.
This is deterministic-by-design given its concrete mechanism. The system doesn't become reliable because the model got more obedient; it becomes reliable because the load-bearing rules were moved to where obedience isn't a variable.