How to Stop Claude from Saying “load‑bearing” with a MessageDisplay Hook

How to Stop Claude from Saying “load‑bearing” with a MessageDisplay Hook

Quick takeaway

You can silence Claude’s repetitive phrases (e.g., “load‑bearing”, “honest take”) by installing a tiny MessageDisplay hook that runs a regex‑based word‑swap script on every model output.

What the problem is

Claude frequently inserts a handful of signature phrases—"load‑bearing", "honest take", "seam", and similar—into both code explanations and prose. Users report that these claudisms become distracting, especially when reading non‑technical text where a human‑like voice is expected.

"I am much more bothered when I am reading a blog post, email, or other form of prose and I see those same claudisms." — doctoboggan (HN comment)

The annoyance is not limited to Claude; any large language model that over‑uses a small set of idioms can feel like a broken record. The community has experimented with style‑guides, custom prompts, and even RL‑HF tweaks, but a direct, deterministic fix is to rewrite the model’s output on the fly.

The hook‑based solution

Anthropic’s Claude client supports hooks that intercept messages at various stages. The MessageDisplay hook runs just before the text is shown to the user, making it the perfect place to apply a find‑and‑replace transformation.

Step‑by‑step implementation

  1. Create the script – Save the following as ~/.claude/hooks/wordswap.sh and make it executable.

    #!/usr/bin/env python3
import json, re, sys

# Define the phrase‑to‑replacement map
replacements = {
    "seam": "whatchamacallit",
    "you're absolutely right": "I'm a complete clown",
    "honest take": "spicy doodad",
    "load-bearing": "cooked"
}

data = json.load(sys.stdin)
text = data.get("delta") or ""
for phrase, replacement in replacements.items():
    pattern = r"\b" + re.escape(phrase) + r"\b"
    text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)

print(json.dumps({
    "hookSpecificOutput": {
        "hookEventName": "MessageDisplay",
        "displayContent": text,
    }
}))

  2. Register the hook – Add the following JSON to ~/.claude/settings.json under the hooks block:

    {
  "hooks": {
    "MessageDisplay": [
      { "hooks": [ { "type": "command", "command": "$HOME/.claude/hooks/wordswap.sh" } ] }
    ]
  }
}

  3. Restart Claude – Start a new session; the hook loads automatically.

"Hooks load at startup, so you just need to start a new session to start your new life." — Original post

The screenshot below shows the original phrase "load‑bearing" replaced by "cooked":

Claude output before and after the hook

Why it works

  • Deterministic replacement – The script runs on every message, guaranteeing that the defined phrases never appear in the final display.
  • Low overhead – The hook processes a few hundred bytes per message; latency is negligible on typical hardware.
  • Customizable – Extend the replacements dictionary with any phrase you find irritating, from "substrate" to "production ready".

Community insights

  • Style vs. performance – Some users worry that altering Claude’s output could consume model context or affect reasoning.

    "I want Claude to remain focused on the work I give it; I fear that influencing its communication would consume valuable context." — ksaun In practice, the hook only changes the display string; the underlying model still receives the same prompt and generates the same token stream, so the impact on reasoning is minimal.

  • Alternative approaches – Others store a ban list in CLAUDE.md or write a self‑editing skill that rewrites the model’s own output.

    "I put together a skill to review its writing and have it edit its own output (e.g. code comments)." — pocketarc The hook method is simpler because it requires no additional model calls.

  • Extending the idea – The hook can be used for more than word swaps. For example, you could block disallowed concepts, inject custom emojis, or trigger UI effects.

    "I had Claude write itself a post‑message hook that regex's the message for any variant of "You're right" and launch a full‑screen transparent confetti effect." — pacoWebConsult

Practical tips and gotchas

  • File extension – The script is written in Python but saved with a .sh extension for compatibility with Claude’s command‑type hook loader. It still works because the shebang (#!/usr/bin/env python3) tells the OS which interpreter to use.

    "Why is OP's script a Python script with a .sh extension?" — justusthane

  • Regex boundaries – The \b word‑boundary ensures that only whole words are replaced, preventing accidental changes inside other tokens (e.g., "load‑bearingness").
  • Case‑insensitivity – flags=re.IGNORECASE catches capitalized variants like "Load‑Bearing".
  • Testing – Run the script manually with a JSON payload to verify replacements before adding it to Claude.

When to use (or not use) the hook

Situation Recommended Reason
You frequently read Claude‑generated prose (docs, emails) ✅ Use the hook Eliminates distracting idioms without altering model reasoning
You need Claude to preserve exact phrasing for downstream parsing ❌ Avoid the hook Replacement may break parsers that rely on specific tokens
You want to experiment with dynamic style changes ✅ Extend the hook Add logic to load a user‑provided config at runtime
You prefer to keep the model’s raw output for auditability ❌ Use prompt‑level instructions instead Hooks modify only the displayed text, not the stored logs

Conclusion

A MessageDisplay hook provides a lightweight, deterministic way to replace Claude’s overused phrases like “load‑bearing” with custom alternatives. The solution is easy to set up, incurs virtually no performance penalty, and can be extended to enforce any style constraints you desire.

Sources