Apply "high-agency strategy" (Salience × Memeticity) to agent-facing rules — start with the delegation-adherence gap

[arzafran]

Why this belongs here

cc-settings is a high-agency-strategy system. Its whole job is to make an autonomous agent (Claude Code) execute our engineering strategy per-decision, without a human in the loop. Matt Strom's piece argues that as AI shrinks teams, "the strategy itself has to do the old job of management" — coordinate autonomous actors the way simple flocking rules coordinate starlings. That's a near-spec for what CLAUDE.md + skills + hooks + rules are trying to do, and it names a gap we have.

Reference: https://mattstromawn.com/writing/high-agency-strategy/

The lens

Strom scores strategy on a 2×2:

• Salience — can the actor understand and actually use it for a per-decision call?
• Memeticity — does it replicate faithfully across turns/sessions/sub-agents without anyone enforcing it?

cc-settings already nails most of his prescriptions — but mostly the memeticity ones:

Prescription	We already do
Error-detection / checksums	supply-chain hook fingerprint (SHA256 of hooks block, verify-hooks.ts)
Canonical documents	CLAUDE.md as SSOT, skills library
Pair rules with reasoning	delegation block explains why ("Opus 4.8 under-spawns subagents…")
Repeat across channels	per-turn hook reminders (delegation nudge, doc-staleness, db-sync)

The gap (evidenced, with some irony)

The prescriptions we're weakest on are the salience ones. Live evidence from one real darkroom-os session: the delegation reminder ("MUST delegate when 3+ files / 10+ tool calls / security-sensitive code") fired ~15 times, and the agent reasoned its way past it nearly every time — exactly the failure Strom predicts: repetition without salience → low adherence. (Written, for what it's worth, by the agent that kept ignoring the rule.)

The hook detects the condition and nudges, but:

• it's a soft nudge, not a per-decision heuristic the agent can't rationalize around, and
• there's no error-detection that flags the actual violation (only the precondition), so nothing closes the loop.

Worse, several per-turn reminders fire every turn (delegation + doc-staleness + db-sync). When everything nags, the agent learns hooks are background noise — which lowers the salience of all of them, including the important ones.

Proposed direction

1. Audit rules by adherence, not existence. For each standing rule, ask: does the agent actually change behavior when it fires? If not, it's low-salience noise that trains the agent to tune hooks out.
2. Compress high-value rules into per-decision heuristics, not paragraphs. A one-glance trigger the agent can derive from first principles beats prose it skims.
3. Upgrade detection → enforcement where it matters. The delegation hook already computes "N tool calls without an Agent call." For clear MUST-delegate cases (security-sensitive edit, 3+ file write), escalate from a soft nudge to a harder signal — e.g. a Stop-hook-style "again" block, or require a one-line justification for NOT delegating before proceeding.
4. Cut nag fatigue. Fewer, higher-salience signals replicate better than many low-salience ones firing on every turn.

Worked example to start with: delegation

It's the best test case — universal, the reasoning is sound (Opus 4.8 under-delegates), and it has proven low adherence. A first PR could rework just the delegation guidance from "repeated nag" → "per-decision heuristic + a hook that escalates on a clear violation," then measure whether adherence improves across a few sessions. If it works, run the same Salience × Memeticity pass over the rest of the rule set.

Note

The same lens transfers to darkroom-os (shared/PRINCIPLES.md / GLOBAL.md / ROUTER.md as fleet-coordination docs) and darky (SOUL.md as compressed working-memory strategy — we recently hit a salience bug there where SOUL.md steered the bot away from a tool it had). But cc-settings is the native home: it's the layer whose entire purpose is strategy-that-coordinates-an-agent.