# Where a rule lives

> A rule can live in one of two places, and two homes] shows where each one leads.

Page: Methodology · Start
Canonical: https://banes-lab.com/disciplined-methodology#from-chat-to-tree

This section is stop 7 of 102 in the learning route. Previous: [06 - Three encodings](https://banes-lab.com/disciplined-methodology/start/three-encodings.md). Next: [08 - Rules with names](https://banes-lab.com/disciplined-methodology/start/rules-with-names.md). It builds on [06 - Three encodings](https://banes-lab.com/disciplined-methodology/start/three-encodings.md).

A rule can live in one of two places, and [G1·a two homes](https://banes-lab.com/disciplined-methodology#from-chat-to-tree-panel-a) shows where each one leads. It can live in the conversation, where the developer has to restate it and hope it is followed, or it can live in the tree, where the model is given the policy file at the start of every session and a check refuses any change that breaks the rule. Everything in this method lives in the tree: as [policy as code](https://banes-lab.com/records/arch/policy-as-code.md) where a check can enforce it, and as a line in the policy where only the model's conduct can. An instruction that has to be restated is a mechanism that has not been built yet, and the ontology calls the state it leaves behind [manual-only governance](https://banes-lab.com/records/arch/manual-only-governance.md).

### Discipline decays, mechanism holds

Rules that live in a chat have to be restated every session, and each restatement is a chance for them to drift. The session starts well, the instructions fade as the context fills up, and by the end the model is back to its default behaviour. A rule held only by discipline is decided again every time it applies, and every new decision is a chance to decide differently.

For this reason I hold rules in the tree rather than in the conversation, because a rule in the conversation decays and a check in the tree does not. Discipline is turned into mechanism as soon as a rule has been stated twice, rather than stated a third time. In practice, each instruction you keep repeating moves into a file the model is given at the start of every session, and each check you keep performing by hand moves into a command the pipeline runs. Once the mechanism holds, the old habit is dropped, because a habit kept alongside its mechanism is a second home for the same rule.

To check this, delete your custom instructions for one session. What still holds is mechanism, and what breaks was discipline. A conversation is the right place for a rule only when the model has no access to your files; as soon as it does, the tree is the right place.

The test that tells the two apart is whether anything would object if the rule stopped holding, the same objector test that the section [stating an invariant](https://banes-lab.com/disciplined-methodology/collaborate/stating-an-invariant.md) applies to a whole topology. A rule in a conversation has no objector: once it is forgotten, nothing notices. A rule in the tree has one of two. Either a check refuses the change that breaks it, or a policy line states it in the same words at the start of every session. The second is weaker than the first, because the model can still fail to follow a line it has been given, but it is still stronger than a memory, because a policy is delivered to every session and a memory reaches only the party who remembers to look it up.

Friction between several parties working on one tree is the same question at a larger scale, and [coordination is software](https://banes-lab.com/disciplined-methodology/collaborate/coordination-is-software.md) answers it. When two parties lose a write, leave a stale item behind or miss a message, the first question is what the [shared surface](https://banes-lab.com/pag/orchestration/shared-surfaces.md) is missing, never who should have been more careful. A rule added without a mechanism behind it only asks for more care, and it decays at the same rate the care did.

G1·a two homes

```mermaid
flowchart TB
rule["A rule"]
conversation["Held in the conversation"]
restated["Restated every session"]
fades["Fades as the context fills"]
defaults["The model is back to its defaults"]
tree["Held in the tree"]
policy["A policy file given to the model every session"]
check["A check that runs on every change"]
holds["Held by the tree, not by memory"]
rule --> conversation --> restated --> fades --> defaults
rule --> tree --> policy --> holds
tree --> check --> holds
```

## Links to

- [Policy as Code](https://banes-lab.com/records/arch/policy-as-code.md)
- [Manual-Only Governance](https://banes-lab.com/records/arch/manual-only-governance.md)
- [Stating an invariant](https://banes-lab.com/disciplined-methodology/collaborate/stating-an-invariant.md)
- [Coordination is software](https://banes-lab.com/disciplined-methodology/collaborate/coordination-is-software.md)
- [Shared surfaces](https://banes-lab.com/pag/orchestration/shared-surfaces.md)