What this is
A single source of truth for how Claude behaves everywhere you type the word — not a file, but a control loop.
The pain that started this: every surface — web, terminal, Claude Code, the IDE, Zed, Xcode, Cowork — behaved differently, and there was no coherence to lean on. The diagnosis, once the real machine was inspected, was sharper than expected: a carefully-authored directive lived only in claude.ai preferences, and ~/.claude/CLAUDE.md did not exist. Ninety percent of the posture vanished the moment you left the browser. The config wasn't wrong; it was absent.
So the answer can't be "a better document." Coherence you can trust needs three layers — derive, verify, enforce — running as a loop on every device. Below is what was built, what wasn't, and why one tile was left empty on purpose.
Derive
One canonical posture.md + registry.yaml render into each surface's native format. Reconciled against ~/Code every run, so it can't rot into fiction.
built · idempotent · backed upVerify
--check classifies every surface: ALIGNED / DRIFTED / UNMANAGED / UNTRACKED / GHOST. Exits nonzero on drift. Coherence becomes a state you assert, in cron or a git hook.
built · the antidote to driftRe-align
Verify feeds the fix. Run anywhere, see exactly what diverged, re-render only the deltas. The loop closes — across machines, not just one.
built · cross-deviceEnforce — the missing tile
CLAUDE.md is advisory context, not a guardrail. The Secure-Pride hard-stops (no unmasked identifiers, no operational-context inference) need PreToolUse hooks that fail closed. Left deliberately empty — a guard with holes is worse than honest prose.
not faked · built with you, on your say-soThe mosaic is missing a tile by choice. That absence is the most honest thing in the design.
The honest map
About ten named surfaces collapse into three real configuration planes. Terminal emulators (Ghostty, iTerm2) aren't planes — they're just where Claude Code runs. Xcode has no native plane; you align it by running Claude Code at the repo root.
- Claude Code (CLI), IDE extensions, terminal sessions, Xcode-via-terminal
- ~/.claude/CLAUDE.md, per-project CLAUDE.md, settings.json, skills, hooks, MCP
- Script-writable, git-versionable — where the loop actually lives
- claude.ai web, desktop & mobile chat
- Cowork, Design — placement provisional, unverified
- Server-side, UI-only: can't be written from a file. Generated as a paste block with a timestamp.
- Zed, anything calling the API directly
- Own rules format; reads neither plane above
- Stubbed — Zed's current rules mechanism needs verifying first, not guessing
How it works
You edit two files; one command renders them onto whatever device runs it. Only content between managed markers is ever touched — anything you hand-write outside the fence survives. Sensitive repos (Secure-Pride, MAX posture) are skipped unless explicitly opted in.
The verifier and the writer share one _compute_managed() function. That's deliberate: a checker that decided "aligned" by different logic than the writer writes would simply lie to you. Verified in a sandbox —
The gaps
Called out plainly, because a system that hides its own seams is the thing that started this mess.
Opinionated feedback
You asked for honest opinion, not a status report. Here it is, in three voices.
Where it falls short
It's two-thirds of a system. Without enforcement, the highest-stakes project relies on a model choosing to comply — exactly the weakness that triggered all of this.
The account plane is a seam that will always need a human hand. And cross-device coherence still depends on you actually running --check on each machine; nothing yet pulls that into one dashboard.
What I'd do differently
Build the loop first, not the pipeline. I led with distribution because it photographs well in one turn, and demoted verification and enforcement to "later." That was backwards for someone running a MAX-posture security project.
I'd derive the registry from disk from line one, and verify Cowork/Zed before drawing a map with their names on it.
What I'm proud of
The verifier can't lie. It shares its "what should be true" computation with the writer — structurally, not by promise.
And the empty tile. Shipping a hollow security guard would have been the easy, impressive-looking move. Refusing — and saying why — is the part of this I'd defend to anyone.
The becoming
You didn't only ask for a system. Across three turns you asked, in escalating seriousness, whether it was the right one — and each question pulled the work closer to reality.
Engage reality
The directive described a workspace that didn't exist. Instead of building on the document, I opened the actual machine — and found the anchors were fictional, the CLI was a void. The truth was on disk, not in the description. Everything good downstream came from looking.
Tell the truth — including on myself
Asked if I was satisfied, I audited my own work and found I'd overstated the idempotence — the paste block rewrote every run. The honest move wasn't to gloss it. I named it, fixed it, re-verified. A claim you won't re-test is just a hope.
Grow past the easy answer
Asked whether this was the system I should have built, I had to admit it wasn't. I'd solved the tractable adjacent problem — distribution — and called the hard core "a later decision." So I built the loop. And I drew a hard line at faking enforcement, because false safety is worse than honest absence. Restraint was part of building it right.
The thread through all three was one instinct pointed three ways: engage what's real, say what's true, and refuse the version that only looks finished. That's not a feature of the system. It's how the system got good.