Claude Code Digest — Jun 20–Jun 23

Claude Code is shifting from a chat box into governed infrastructure: the teams pulling ahead are wiring policies, auth, and agent workflows now, not later.

7-tier memory system

Trending Now

🔥 Policy-by-hook beats policy-by-prompt: PreToolUse is the new guardrail
If you still rely on CLAUDE.md for “don’t do X,” you’re trusting the model to remember. PreToolUse hooks execute outside the model, so you can hard-block deploys, migrations, and destructive commands before they happen. Move critical rules into shell-enforced hooks and keep CLAUDE.md for guidance, not enforcement. 🔥 MCP is getting split into native servers, not wrapper scripts
The big design lesson this week: stop wrapping CRUD endpoints and start exposing the smallest trustworthy action surface. Native MCP servers with permission enforcement are replacing brittle copy-paste workflows, and progressive discovery is becoming the pattern for keeping tool lists usable instead of token-heavy. 📈 File-based memory is becoming the workaround for Claude Code’s cold start
MACCHA’s 7-tier file memory shows a practical path to persistence without running a daemon. The move: store preferences, project rules, and lessons in repo-local files so every new session inherits context instead of re-learning it. This is especially useful for multi-agent teams that keep losing state between runs.

Best Practices

Move destructive rules into PreToolUse hooks to guarantee enforcement
Before: “please don’t run migrations in prod” lives in CLAUDE.md and can be ignored. After: the hook blocks the command before the model can execute it, turning a soft preference into an actual control. Use progressive discovery in MCP servers to keep tool menus from exploding
Before: dumping 40+ tools into Claude Code makes selection noisy and burns context. After: the agent only discovers the next relevant capability, which keeps tool choice sharper and reduces accidental misuse. Persist project memory in repo files instead of a daemon
Before: every new Claude Code session starts cold and re-asks the same questions. After: a file-based memory layer carries preferences, rules, and prior decisions across sessions with zero background service to babysit.

Tools & MCP

MACCHA — A 7-tier file-based memory system for Claude Code that persists preferences and lessons across sessions — avoids cold-start rework without running a daemon. Namecom-CLI — An agent-friendly DNS CLI with a bundled Claude Code skill that manages Name.com records idempotently via the v4 API — cuts manual DNS edits and repeat mistakes. Trace Commons — One-command trace donation to a Hugging Face dataset — turns solved Claude Code sessions into reusable open data instead of private dead ends.

Multi-Agent Patterns

Cross-agent memory files
MACCHA keeps a shared, repo-local memory trail so multiple agents can inherit preferences, project rules, and prior lessons without depending on one live process. Governed multi-agent workflows
The digest points to teams wiring policies, MCP auth, and agent permissions before scaling usage, so agents can operate inside explicit guardrails instead of ad hoc trust. Trusted-action MCP servers
Native MCP servers embedded into a CMS let Claude Code act like an authorized teammate, not a copy-paste assistant, because permission checks happen at the server boundary.

Community Requests

• A native MCP server benchmarking suite that measures token cost, latency, and tool-selection accuracy across progressive discovery vs. flat tool lists
• A standard way to diff and merge Claude Code memory files across branches and agents without clobbering project rules
• A first-party audit log for PreToolUse hook blocks, so teams can see which commands were prevented and why