Qwen3.7 Plus Doc Translation Mistakes in Your Terminal

Locking the glossary before the first translation request

Most bad translations are decided before the first request goes out. When a term like workspace, session, or tool call has three different spellings across your pages, the model inherits the inconsistency and spreads it through every file it touches. Qwen3.7 Plus is a strong translator mainly because it follows context faithfully, and the wrong context is followed just as faithfully as the right one.

Start with a glossary file checked into the repo next to the docs. Write down every product noun, every verb you refuse to localize, and the exact strings for endpoint paths, CLI flags, environment variables, and SDK class names. Keep it short enough that you can paste the whole thing into a prompt without worrying about cost, and mark each entry as keep, translate, or transliterate so the model never has to guess.

Add one already-approved translated page next to the glossary as a style sample. That single reference page does more than a paragraph of tone instructions, because it shows the model how you handle headings, sentence length, imperative mood, and code comments. When your team later disagrees about phrasing, you can point at the sample instead of rewriting prompts from scratch.

Naming the reader, the platform, and the code language in every prompt

A prompt that says translate this documentation is missing the three facts that decide the output. Say who reads it: backend engineers wiring up authentication, or product managers skimming a getting started page. Say where it lands: a docs site, a terminal help screen, or a comment block in a source file. And say which code language appears in the examples, because a Python snippet that keeps English variable names is a different job than a PHP snippet in a Spanish tutorial.

State the register explicitly. Developer documentation usually wants short sentences, second person imperatives, and no marketing adjectives. If your audience is engineers who live in an editor and terminal, they will notice immediately when a translation starts padding a two-line curl example with reassurance about how easy everything is. Tell the model to drop the padding instead of expecting it to infer restraint.

Put the constraints in a reusable prompt file rather than retyping them for every page. I keep a translate.txt in the docs tooling directory that ends with a short checklist of forbidden changes, and I pipe each file through it from the terminal. The habit pays off because the prompt never drifts between a Friday afternoon batch run and a hurried Monday fix.

Chunking long reference pages instead of pasting the whole doc

Pasting an entire reference into one request looks efficient and usually is not. Long inputs make the model conserve, so headings get summarized, warnings get softened, and edge-case notes quietly disappear. Split by section boundaries and keep each chunk under a page, with the glossary repeated at the top of every request.

Chunking also makes failures cheap. When one section comes back wrong, you regenerate that section instead of re-rolling the whole file. Retries stop feeling like a gamble, and you can hand a single questionable section to a second model, for example Qwen3.8 Max, to see whether the disagreement is a translation issue or a source clarity issue.

Keep a stable prefix across chunks. If your glossary and style sample stay byte-identical at the front of every request, cache hits cover most of the repeated input. Fluxo bills per real token including cache reads and writes, with no monthly fee, so stable prefixes lower your bill instead of merely making the run tidier. It also keeps tone uniform across chapters that were translated days apart.

Protecting code fences, placeholders, and endpoint names from translation

Code is where documentation translation breaks most visibly, because a well-meaning translation of a shell command or a JSON payload is broken code with perfect grammar. Tell the model that fenced blocks are immutable except for comments and natural-language strings, and that placeholders such as YOUR_API_KEY must survive byte for byte.

Ask for a small structural report at the end of every chunk: the number of code fences in and out, the heading depth, and any line the model refused to translate. Comparing fence counts takes seconds and catches the classic failure where a closing fence is dropped and the rest of the page turns into one giant code block in the docs build.

• Keep endpoint paths, HTTP methods, and SDK class names exactly as they appear in the source.
• Leave shell commands, environment variables, and configuration keys entirely untranslated.
• Translate comments and user-facing strings while preserving indentation and syntax highlighting.
• Preserve every placeholder token so template rendering does not break after the merge.

Auditing links, numbers, and version names after the run

Models are careful with links and numbers right up until they are not. A trailing slash changes, a fragment identifier gets translated, a version number drops a patch release, and the page still looks clean in a diff review. Write a small script that extracts URLs, semantic version strings, and bare numbers from both source and target and reports anything that moved without matching.

Then read the first and last paragraph of each translated section out of context. Awkward transitions usually mark the spot where chunk boundaries cut a thought in half, and a quick manual splice is better than another full regeneration. Do the same for headings, since a heading that reads like a sentence tells you the section summary leaked into the navigation.

Finally, build the docs locally before you merge. Broken tables, overflowing code blocks, and doubled-up anchors show up in the rendered site long before a reader files a complaint. If the problem is in the relay layer rather than the translation itself, there is no support mailbox, but you can leave a note on the contact page after signing in and we will pick it up there.

Pricing the iteration loop with real token accounting

Translation quality comes from iteration, so price the loop instead of guessing at it. A full docs pass with several retries is still cheap when you pay per real token instead of a monthly seat, but you should know which files dominate the spend. Reference pages with long examples usually cost more in input than output, while prose-heavy tutorials invert that ratio.

Watch cache reads and cache writes when you optimize, because a run that rewrites prompts per file can spend more on cache writes than it saves in output. Keep the invariant part of the request stable and vary only the chunk. That pattern also behaves best in a terminal pipeline, where the same key and base URL feed a quick one-file fix or a nightly batch without extra configuration.

All of this runs through one key and one base URL, https://api.fluxorelay.com, which sits in front of Qwen, Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Grok and more. The same call works from Claude Code, Codex, Gemini CLI, or any OpenAI SDK, so a translation script written for one tool does not need rewriting when you switch. And when people you invite start paying for their own runs, you earn a referral share of what they spend.

If you want to try this loop on your own documentation, creating a Fluxo account is a gentle first step: one key, one base URL, and no monthly fee waiting behind it.