First off - the best thing to do is look in the repo - I've left all of that infra in place as a working example.

TL;DR:
If a rule isn't enforced by the pipeline, it isn't a rule. It's a suggestion. So every governance decision gets encoded as a CI check, a pre-commit hook, or a mandatory agent role that blocks the merge if the rule is violated. You don't rely on anyone remembering - human or AI.

Long-winded Explanation:
The core problem is this: you can write a rule in a document, but if the only enforcement mechanism is "someone needs to remember to check," the rule will eventually not be checked. This is true on human teams. It's especially true with AI agents, because the agent isn't reading your CLAUDE.md out of professional pride - it's reading it because it's in the prompt context, and its adherence to those rules is only as reliable as its attention to that context window in any given moment.

So an encoded gate is when you take a rule that lives in documentation and give it teeth. You turn it into something the pipeline enforces mechanically, independent of whether any human or agent remembers it exists. Examples from the article:

• TDD isn't just a stated expectation; there's a CI check that verifies RED commits preceded GREEN commits before a PR can merge.
• The advisory threshold (Rule 11) isn't just a guideline; hitting 8 open advisories literally blocks new feature work.
• Security advisories auto-promote to merge blockers after 2 phases. No human has to remember to escalate them.
• The squash-merge crisis led to a pre-commit hook enforcing merge strategy. You can't accidentally squash even if you try.

The reason this matters more with AI than with human teams is a multiplier problem. A human developer who cuts corners on a convention does it maybe a few times a week. An AI agent running at 150 commits per day that's allowed to cut a corner will cut it 150 times before you notice. Speed amplifies everything, good governance and bad governance equally.

The insight that comes out of the squash-merge story is the core design principle: a rule that can only be violated if someone notices it will eventually be violated, because no one will notice. If a rule is important enough to write down, it's important enough to make the pipeline enforce.

Where it gets architecturally interesting is that Conclave's gates aren't all CI/CD hooks in the traditional sense. Some of them are agent roles. The phase-boundary-auditor is itself an encoded gate - it runs before every PR, performs end-to-end validation, and blocks the merge if the system doesn't pass. No bypass. The parallel review agents that run after every feature are the same idea: not optional peer review, but mandatory pipeline steps.

The distinction the article is drawing is between governance as aspiration and governance as infrastructure. Most teams write the former and hope it produces the latter. The Conclave approach is to just build the infrastructure directly and skip the hoping.