How to Translate ‘Claudish’ Back to Plain English

If you’ve spent any time with Claude or Claude Code, you know the style. The polished sentence. The semicolon that sets up a sharper rephrase. “The honest shape is asymmetric” types of sentences that say a one-line thing in a paragraph’s worth of elegant vocabulary. Someone on Reddit called it a language of its own — “Claudish” — and actually went and built translators for it. I tested the main one on a CPU-only box this week, and it’s genuinely fun and useful.

There are really two useful things here. One is a Python package that translates between plain English and Claudish in both directions, running entirely on your machine. The other is a Claude Code plugin that rewrites Claude’s dense replies into plain English as you read them. They attack the same joke from opposite ends, and both are worth a look depending on what annoys you more.

What Is “Claudish,” Anyway?

Claudish is the running bit about how Claude phrases things. It leans on contrastive reframing (“X, not Y”), structural metaphors (gates, surfaces, seams, handoffs), and process-heavy vocabulary like “gating,” “landed,” “parity,” and “hard constraint.” The punchline is that these flourishes often wrap a fairly simple fact in a lot of ceremony.

Look at what the translator does with a short sentence I threw at it. Input: “Only owners can merge.” Output: “Merge is owner-gated; only owners can land.” Same fact, but now it sounds like a platform changelog written by a very careful engineer. That is the whole game in one example.

It’s not that this is wrong or useless — Claude’s precision is genuinely part of why people trust it for code reviews. But when you’re skimming your terminal at 8AM, you sometimes want the plain version. That’s exactly the gap these tools fill.

Tool 1: The Local English ↔ Claudish Translator

The project is programasweights/claudish on GitHub. It ships two tiny programs compiled for ProgramAsWeights — a framework that compiles natural-language specs into compact neural programs that run on your machine after a one-time model download. You can use the live web demo, or run it locally with Python.

Install is one line:

pip install programasweights

Once it’s in, loading both functions and running a translation is straightforward:

import programasweights as paw

to_claudish = paw.function("ca9d5165b6c8e6615529")
to_english = paw.function("e469f61ccab2699fbd51")

print(to_claudish("Only owners can merge."))
print(to_english("The honest shape is asymmetric: the data is correct; the format is hard to read."))

The first run downloads a small interpreter model — Qwen3 0.6B, quantized to Q6_K, roughly 590MB — once, into a local cache. After that, everything runs on CPU with no API key and no network round-trip.

What I Actually Measured

I ran this on an ordinary WSL box with no GPU. The first invocation downloads the base model and the two programs, which took a couple of minutes in total. Once loaded, each translation completes in well under a second — I clocked the round-trips at about 0.3 to 0.4 seconds each. That’s the key pattern these compiled-models projects are chasing: a big one-time cost, then fast, local, private inference.

Here’s the round-trip it produced for me. English in: “The release can go out after Alice approves the final report.” Claudish out: “Alice’s final-report approval is the hard gate here; the release can land only after that.” And running that Claudish output back through the reverse function collapses it to roughly the original intent. That bidirectional symmetry is the part that feels like a real translator and not a one-way filter.

Why Local Matters

For a joke tool, this is oddly aligned with a serious principle: your prompt text stays on your machine. Nothing about your phrasing is shipped to a third party for the rewrite. I’ve written before about running agent tools locally and how much control that buys you — the same logic applies here. It’s also a nice, low-stakes way to get a feel for running a small model locally without provisioning a GPU.

Tool 2: The Claude Code Plain-English Rewriter

The project that started the whole thing is gvzdv/claudish-to-english — the plugin that crossed a few hundred GitHub stars within its first day and made the rounds on r/ClaudeAI. It’s a Claude Code plugin that appends a plain-English rewrite underneath each of Claude’s replies.

Here’s the elegant design detail: the rewrite is display-only. Claude’s actual reasoning and the saved transcript keep the original text. Only what you read on screen changes. So you never lose the precise version — you just get a faster-read one on top of it.

How to Install It

The plugin can be installed straight from its repo:

/plugin marketplace add gvzdv/claudish-to-english
/plugin install claudish-to-english@gvzdv-plugins

Or, to try it for a single session without installing:

claude --plugin-dir /path/to/claudish-to-english

By default it uses a local Ollama model for the rewriting, so the whole thing stays on-device. If Ollama is down, the model isn’t pulled, or a request times out, the plugin fails open — you simply see Claude’s original text, untouched. A one-line notice tells you why the rewrite was skipped. That “never swallow the answer” design is what made reviewers trust it.

The Provider Angle

Beyond Ollama, it supports the codex CLI, the Anthropic API, and any OpenAI-compatible API — swap in whichever fits your setup. There’s also an opt-in second hook that rewrites Markdown files into plainer language when they’re written or edited, which could be handy if you’re tired of painfully formal generated docs.

If you already run Claude Code in your daily flow, this is a genuinely useful add-on. It’s a small example of people hacking Claude Code to work the way they actually want, which I can’t help but appreciate — and a lighter reminder of why productive output, not marketing, is what business users actually reward.

Why Bother With Any of This?

Beyond the comedy, there’s a real skill underneath. Learning to recognize Claude’s style — and to restate it plainly — makes you a better reviewer of AI output. When you can spot the wrapper and pull out the actual claim, you stop being impressed by the eloquence and start checking the substance. That’s a habit worth building, especially if you’re delegating real work to agents. It’s the same reason I wrote about why heavy AI use doesn’t automatically earn reader trust — the prose is part of the trust problem.

It’s also a reminder that the tone of an AI answer is a knob, not a fixed property. If the output style doesn’t fit your team’s docs or your own reading speed, you don’t have to live with it. You can translate it, rewrite it, or just ask for plainer language directly.

The plain-English rewrites are a nice complement to the work I’ve done on building your own AI routing and control layer — same spirit, smaller scale. Fewer surprises in your terminal, more of the signal and less of the ceremony.

Wrap-Up

Both tools are free, open source, and respect your privacy by default. The Python translator is perfect if you want to play with the concept on any machine without installing Claude Code; the plugin is the one you’ll actually use daily if you’re already a Claude Code regular.

Give the demo a spin with one of your own messages. Feed it something like “Check this diff before merging,” and see exactly how much ceremony a careful writer can add — then run it back and watch it compress. It’s a fun ten minutes, and it might just make you a slightly sharper reader of everything an AI tells you from here on.