fluent-korean: a Claude Code output style for Korean that does not read like machine output

The failure mode this plugin is aimed at

Coding agents are tuned to spend fewer tokens and to survive context limits, and the README argues that this pressure is exactly what makes their Korean worse. The symptoms it names are specific: dropped particles and endings, telegraphic strings of nouns, and vocabulary swapped for metaphor. The result is output that takes effort to parse and that can be misread, and the README adds a second-order concern: if reasoning is enabled, low-quality Korean in the reasoning trace can feed back into the reasoning itself. In multi-agent setups where prompts and artifacts pass between agents in Korean, the README says the degradation compounds at each step until meaning loss starts affecting the quality of the work, not just the prose. That compounding case is the strongest argument for the plugin, because a fix applied once at the system prompt level is cheaper than repairing Korean at every hop.

Pre-emptive constraint rather than post-hoc editing

The mechanism is an output style, which in Claude Code means text appended to the system prompt. The README states this plainly: the tool disciplines Korean use in advance, before generation, rather than correcting it afterward. That distinction matters when you compare it with the projects the README itself points elsewhere: im-not-ai, korean-skills, and the korean-humanizer feature in k-skill. Those are framed as skills for correcting translationese, trimming AI-sounding phrasing, and removing spelling errors, which implies a pass over finished text. fluent-korean is the opposite layer. It cannot fix a sentence that was already written badly, and it cannot enforce a house style that is not expressible as a standing instruction. What it can do is shape the distribution of sentences the model produces in the first place. The README is honest that the guideline text is portable: the same prose can be pasted into other AI environments as a plain writing instruction, with Claude Code being the environment it was built for rather than the only one it fits.

Two output styles and a directory of markdown

The plugin contains two output styles. fluent-korean keeps Claude Code's coding instructions and is meant for coding work. fluent-korean-not-coding drops those instructions and is meant for situations where Claude is not editing code directly. The underlying artifacts are markdown files under plugins/fluent-korean/output-styles/, and the README describes the general principle as selecting the file you want and inserting its body in the appropriate place. That means the plugin install is a convenience wrapper, not a requirement. On Claude Code CLI you can skip the plugin and drop the markdown into ~/.claude/output-styles/ or .claude/output-styles/ instead, which is also the path to take if you want the per-block customization described later in the README, because plugin installs risk having those edits overwritten on update. The README also notes that both variants contain a clause telling the model not to write in Korean what should be written in English, and that the coding variant additionally carries a clause about subagent prompts in Korean. It then says directly that how well those clauses hold varies a lot by situation and that you should observe and adjust them yourself. Treat that as the maintainer telling you the subagent behavior is unverified in general, not as a guarantee.

Installing it, and the settings keys that actually switch it on

The README gives two commands for Claude Code CLI, run after starting Claude Code: /plugin marketplace add snflkd/fluent-korean followed by /plugin install fluent-korean@fluent-korean. After that, open /config or the equivalent menu, find the output-style entry, and pick one of the two. Because output styles are read at session start, the README says you must begin a new session or run /clear before the change takes effect. For environments where you want the style applied without selecting it each time, the README names the outputStyle value in settings.json or settings.local.json. In the Claude desktop app running Claude Code, the config menu has no output-style entry, so the README directs you to CLAUDE.md, settings.json, or settings.local.json depending on scope. In Claude web or the desktop app used as a chat product, the instruction text goes into personal instructions (the profile or general tab for chat, the collaboration tab for cowork) or into project instructions if you want it scoped to one project. The README also recommends a shortcut for the whole install question: hand the repository URL to the model you are already using and ask it to read the install section and explain your specific path. That advice is load-bearing here, because the correct placement genuinely differs per environment and the README does not enumerate all of them.

Optional blocks, and the update hazard they create

The README offers a menu of text blocks to append to the end of the guideline text, chosen by intent rather than by configuration. A block for beginner developers asks for explanations a novice can follow and for restraint on colloquial phrasing. A politeness block rewrites the form of address and uses honorific endings, with a worked example contrasting a blunt question against a deferential one. A block for models that overuse rare dictionary vocabulary asks for commonly used words instead. Another extends the rules to all Korean output, not just reports to the user. One exempts artifact types with their own style guidance, such as fiction, scripts, exam writing and research, and asks the model to check with the user when it is unclear whether the exemption applies. A block for models that keep answering in English states that the model thinks, reports, and outputs in Korean at all times. A final block adds a self-check step immediately before emitting the answer. The README is explicit about the cost of this approach: if you installed via the plugin, updates may overwrite the file, so your appended blocks can disappear. If you care about these blocks, place the markdown yourself rather than installing the plugin.

Token cost, casing failures, and the honest limits

The README states that the plugin uses somewhat more tokens. Restoring omitted sentence components and morphemes increases message token usage and context occupancy, and the system prompt itself is a little larger every session. That is the trade: clearer Korean bought with context budget, which is the same budget the coding agent was compressing to protect. The README also reports configuration failures caused by file name and settings casing, and warns you to be careful with both. Those are the two concrete failure modes documented here. The broader one is stated without hedging: it may not work as well as you want. The tendency gets stronger as instructions multiply, as a task runs longer, and as more priming text accumulates in context. The recommended response is not to keep editing the guideline but to change the harness: the maintainer describes using the output style as the default, switching to a skill-like application when style slips on important deliverables, and configuring the harness to run adversarial verification before the final artifact is produced. That is a real admission that a system prompt instruction alone does not hold across a long session. The README also links a principles document that is marked as still being written, so the reasoning behind the rules is not fully available yet.

Who should take it, and what to check first

The fit is narrow and clear. You drive Claude Code with Korean prompts, or you produce Korean deliverables, or you run agents that exchange Korean text, and you have watched the output degrade in the ways the README lists. The plugin is MIT-licensed, so the practical licence question is not whether you may use or modify it but whether you keep the copyright and permission notice with any redistributed copy; that is a general property of MIT and not legal advice. If your problem is Korean that reads like a translation or is peppered with AI phrasing, this is the wrong layer, and the README says so by pointing at three other projects. If you need a guarantee rather than a tendency, no output style can give you one. The verification steps are concrete: confirm the output-style name and the casing in settings.json or settings.local.json match exactly, since the README attributes failures to that; start a new session or run /clear after switching; and watch a long session and a subagent handoff to see whether the Korean rules hold, because the README says that varies and leaves the correction to you.

Editorial conclusion

Adopt fluent-korean if your Claude Code sessions are driven by Korean prompts or produce Korean deliverables and you have seen the output degrade into dropped particles and noun strings. Do not adopt it if you want a post-hoc proofreader: the README points at im-not-ai, korean-skills and k-skill's korean-humanizer for translationese correction, AI-phrase removal and spelling fixes, and this plugin does none of those. Before trusting it, verify three things in your own setup: that the output-style name and config casing match exactly, since the README reports failures traced to that mismatch; that you start a new session or run /clear after selecting the style, because the change does not apply mid-session; and that the style survives long runs and subagent handoffs, which the README explicitly says it may not.

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. snflkd/fluent-korean on GitHub