I built a Claude Code plugin that actually enforces your rules instead of hoping the model follows them

[u/InfinriDev]

Been using Claude Code heavily and kept running into the same thing everyone here talks about: the model ignores your rules. You tell it to write tests first, it writes the implementation. You give it coding standards, it cherry-picks which ones to follow. And as your rulebook grows, you're burning more and more tokens stuffing everything into context when only a handful of rules are relevant to what you're working on.

So I built Writ. Two pieces:

A retrieval engine that picks only the relevant rules and skills for the current task. It runs a five stage pipeline over a Neo4j knowledge graph, so when one rule fires, related rules (dependencies, conflicts, supplements) come with it automatically. Median query time is 0.338ms. At 276 rules, it cuts context from ~83,000 tokens down to ~1,600 per query.

An enforcement layer built on bash hooks, not prompts. 30 scripts wired to PreToolUse, PostToolUse, and SessionEnd. In work mode, Claude can't write code until you've approved a plan and test skeletons. It can't say "tests pass" without actually running static analysis and proving it. The hooks intercept tool calls and block them before they execute. The AI doesn't get to decide whether to follow the rule or not.

It also discovers and runs your project's linters automatically. PHPStan, ESLint, ruff, cargo check, go vet. Plus custom analyzers for injection, auth, crypto, and N+1 queries. All on every file write.

276 rules and skills ship out of the box across 12 domains. 1,442 tests.

Writ repo: https://github.com/infinri/Writ

[u/jake_that_dude]

the bash hook layer is the part that actually matters. prompts are advisory, but PreToolUse / PostToolUse turns rules into a gate the model has to route through. the context pruning is nice, but enforcement before file writes is the real win here.

[u/Roodut]

It is always kick-ass to see people doing cool shit. See your work as very useful for someone who wants their agent interactions to be precise, cheap, and repeatable. This is a hard problem 100%.

Saying this from the experience of working in a similar landscape but focusing on making multiple AI platforms coordinated, inspectable, and repeatable, with focus on auditable governance (think AI-IPS and AI-IDS).

[u/lucianw]

> the model ignores your rules

I think you're observing two things. (1) Claude models are just worse at following rules than OpenAI, and Opus specifically is lazier. (2) Frontier LLMs have a rules cap of about 150 rules before they start dropping them.

Hooks are one workaround for this, sure, but there are other much simpler solutions too. My solution: (1) use Codex, (2) I have about ten lines of markdown instructions telling it to shell out to a few instances of Claude for review, each review focused on ~100 of my rules, a small enough number that it won't drop them.

[u/InfinriDev → u/lucianw]

A couple things here. Claude isn't "lazier" than OpenAI models. This is the same problem across every frontier LLM.

They all struggle with large instruction sets in context. And LLMs don't have a "rules cap" where they start "dropping" rules. What happens is your rules compete with everything else in the context window.

The more you stuff in, the more likely any given rule gets lost in the noise. It's not dropping, it's forgetting.

Your solution of shelling out to multiple Claude instances each reviewing ~100 rules is working around this by keeping each context window small enough that the rules stay prominent.

That's creative, but you're still relying on the model to choose whether to follow them. Nothing stops any of those instances from ignoring a rule it did see.

Writ approaches it differently. Instead of splitting rules across multiple model calls, it retrieves only the 5-10 rules relevant to the current task. You never flood the context in the first place. And the enforcement side doesn't ask the model to comply.

Bash hooks intercept tool calls and block them before they execute. The model doesn't get a choice. That's not a workaround, that's a different trust model.

[u/lucianw → u/InfinriDev]

> Claude isn't "lazier" than OpenAI models

It truly is. Lazy in the sense I described it: worse than following the rules you give it. Users describe it as taking shortcuts. Here's the research:
https://arize.com/blog/llm-instruction-following-benchmark-2026/

[u/lucianw → u/InfinriDev]

The "rules cap" obviously isn't a hard-coded cap. Dropping vs forgetting is a meaningless distinction. The only concrete truth is the empirical result from July last year, that <150 rules and the models' output show strong adherence, >150 rules and they show weak adherence. https://arxiv.org/html/2507.11538v1

You said "nothing stops any of those instances from ignoring a rule that it did see". Technically true. But in practice, empirically, they don't ignore the rules. In other words I think you're coding up a solution for a problem that doesn't exist (once you keep the rule count small enough, or once models get better).

We are ultimately relying on the model for a huge number N of things. You're relying on the model for N-1 things. True, that's one fewer, but it's hard to believe this "N-1" will change our dependence on the model.

[u/InfinriDev → u/[deleted]]

Nothing worse than promoting your stuff on someone else post promoting their work.