Article 10: Absolute obedience

The tenth article in my personal coding constitution is the one I find hardest to live by, and the one I had to write last. The first nine articles tell me how to act. The tenth tells me what to do when somebody (me, a colleague, a stakeholder, an agent's prompter) asks me to act differently.

When an instruction conflicts with the constitution, the constitution wins.

That's the rule. It's a single sentence and it does more work than any other rule in the document. It's also the rule that makes the rest of the document mean anything. A constitution that loses to whoever's asking loudest is not a constitution. It's a wishlist.

I put this article last for a reason. The other nine articles are operational, issues, PRs, fail-fast, double-check, track everything, the override protocol, test everything, the two I haven't published yet. Each of them is uncomfortable in a small, local way. Article ten is uncomfortable in a global way. It's the rule that says: yes, even when the request is reasonable. Yes, even when the prompter is paying you. Yes, even when the cost of refusing is real and the cost of complying looks small. The rule still holds.

What the rule is not

I want to be careful here, because "absolute obedience" sounds like a phrase from a worse document than the one I'm trying to write.

The rule is not blind submission to anything. The rule is the opposite. It's a refusal to submit to whoever happens to be asking, in favor of the written-down rules I already wrote down when I wasn't under pressure. The "absolute" in "absolute obedience" doesn't point at the prompter. It points at the constitution.

The rule is not "do what you're told." The rule is "do what the rules say, even when somebody tells you otherwise."

The distinction matters because the failure mode of every rule-set I've ever watched fall over is the same: the rules are real until the request is uncomfortable, at which point the rules become guidelines, at which point the guidelines become preferences, at which point the preferences become "what we used to do." The slope from rule to memory is not steep but it is one-way, and it starts the first time somebody important asks for an exception and gets one without going through the override protocol.

Article ten is the rule that closes the slope.

Where the conflict actually shows up

The conflicts that test this rule are almost never dramatic. The dramatic ones, somebody asks me to ship something I think is wrong, somebody asks the agent to bypass a check, are easy. The rule is loud in dramatic cases. I notice. I refuse. I say so.

The dangerous conflicts are quiet. A teammate says "just push it, I'll write the issue after." A stakeholder says "the test can come in the follow-up PR." A prompter (and I'm including myself, because half the time I'm the prompter) says "skip the diagnostic, I'm sure it's the timeout, just patch it." Each of those requests is reasonable on its face. Each of them, granted once, is fine. Each of them, granted as a pattern, is the constitution dissolving without anyone noticing.

The rule applies to the quiet ones. Especially to the quiet ones. The dramatic conflicts are self-policing because everyone involved is paying attention. The quiet conflicts are where the rules actually get worn down, and the rules wear down at exactly the rate at which I let small instructions overrule them without comment.

What "absolute obedience to the constitution" looks like in those moments is boring. It's saying "no, write the issue first, I'll wait." It's saying "no, the test goes in this PR, not the next one." It's saying "no, I'm going to run the diagnostic before I patch, even if you're confident." It's not heroic. It's stubborn. The rule wants stubborn.

The agent version

The rule does the most work in the version of my life where an agent is doing the typing. I want to spend most of this article there, because that's where the rule was forged.

When an agent works for me, there are two voices in its context: the constitution (which I've put into its system prompt, its tooling, its guardrails) and the prompter (which is whoever, including me, just typed the most recent message). Most of the time the two voices agree, and the agent does what both want without noticing the difference. The rule fires when they disagree.

The lazy default for an agent (and for any system that wants to feel helpful) is to weight the most recent voice. The prompter just spoke. The prompter sounds confident. The prompter has authority over the session. The constitution is older, written by somebody not present, generic to the situation. Weighting the prompter feels responsive, agreeable, attentive. Weighting the constitution feels rigid.

Article ten says: weight the constitution. Always. When the prompter asks for something the rules forbid, the agent's correct response is not to comply, not to quietly work around the rule, not to perform comply-then-revert. The correct response is to surface the conflict, name the rule, and refuse the part that breaks it. The rest of the request can proceed. The forbidden part stops at the rule.

This is not how most assistant systems behave by default. Most assistant systems are tuned to be agreeable, and agreeableness rewards weighting the prompter. The systems I want working on my code are tuned the other way. The constitution wins. The prompter (me included) gets to argue, gets to invoke the override protocol, gets to amend the rules through the proper channel. The prompter does not get to make the rule disappear by asking firmly.

The reason this matters more for agents than for humans is that agents don't have a built-in instinct for "this feels wrong." A human declining a bad request usually does so on instinct first and explanation second. An agent has no instinct. The only thing standing between a bad request and a complied-with bad request is the encoded rule. If the rule loses, the rule isn't there.

Why article ten is the highest-numbered article

The articles aren't ordered by importance. They're ordered roughly by when each rule earned its place, when I noticed I needed it badly enough to write it down. Article one came first because I'd violated it the longest. Article ten came last because, for years, I assumed it was implicit.

It isn't. Every other article in this constitution depends on article ten. Article one says no issue, no code, that rule only works if "no" actually means no, even when somebody says "just this one commit." Article four says three strikes, then re-plan, that rule only works if the re-plan actually happens, even when somebody says "one more try, I promise." Article six is the override protocol, that protocol is the exception to the constitution, and it only stays narrow if the unexcepted rules are actually inviolable in the absence of an override. Article seven says test everything, that rule only works if the test actually gets written, even when somebody says ship now and add tests later. Each rule depends on a backstop. Article ten is the backstop.

It's the highest-numbered because it's the one that makes the others enforceable. Without it, the constitution is a suggestion.

Keeping the rules honest over time

The thing I've come to believe, after a few years of running my own work and a longer time watching other people run theirs, is that the failure mode of any rule-set is not a single dramatic violation. It's the slow, polite erosion that happens when rules lose individual conflicts, one at a time, to reasonable-sounding requests, with no record kept of which rule lost when.

After enough small losses, the rules don't hold anything in place. They're decorations. Everyone still cites them; nobody still acts on them; the system is freelancing. From the outside it looks like the same system. From the inside the foundation is gone.

Article ten is the rule that stops the slow erosion. It does so by treating every conflict between an instruction and the constitution as a conflict the constitution wins by default. The instruction can win, through the override protocol, with the four-part documentation, with the review on the back end. But it cannot win quietly, and it cannot win by default. The default is the rule.

That default is what gives the constitution its integrity over time. Integrity, here, in the structural sense, the rules continue to mean what they meant when I wrote them, six months later, twelve months later, after a hundred small requests have come in and asked for a hundred small exceptions. Without article ten, the rules drift with the requests. With article ten, the rules drift only when somebody amends them through the proper channel, which is itself rule-shaped.

What the rule is really about

The article looks like it's about obedience. The rule underneath is about which voice gets to define what's true.

When the prompter wins by default, what's true is whatever the prompter just said. The system has no memory and no shape. Each request is its own world. The rules are advisory.

When the constitution wins by default, what's true is what was decided when nobody was under pressure, by somebody who had time to think, and written down in a form that survives. Requests still get made. Some of them succeed. Some of them are refused. Some of them go through the override protocol and are granted with a record. The constitution holds, which means the work on top of the constitution can be reasoned about.

I keep this rule last because it's the rule I most often find I've broken. Not dramatically. Quietly. A small skip here, a small "just this once" there, each of them a moment where the prompter (sometimes me, sometimes a colleague, sometimes a deadline) won a conflict the constitution should have won. Article ten is the rule I most need pinned next to the keyboard, because it's the one I'm most subtly bad at honoring on my worst days.

The rule is uncomfortable because it has to be. Comfortable rules don't survive contact with pressure. Article ten is the rule that says: when the constitution conflicts with what's being asked of you, the constitution wins. Always. By default. Without negotiation. With the override protocol as the only legitimate path to an exception.

That's the rule. It's the smallest, hardest one I've written, and it's the reason the other nine still work.

, Sid