# Why Not Just Ask Cursor to Add i18n? Where a Coding Agent Gets It Wrong

> A coding agent can internationalize a small app in one prompt. In a real app it misses attributes, invents new keys each session, re-translates everything and breaks plurals. Here's a checklist that fixes most of it, and when a dedicated tool is worth it.
- **Author**: Mohit Sapat
- **Published**: 2026-11-16
- **URL**: https://www.babelize.co/blogs/why-not-ask-cursor-to-add-i18n

---

<p class="lead">You can open Cursor or Claude Code, type &quot;add i18n to this app&quot;, and get something that works. For a small app with one page and a dozen strings, that may be all you need.</p>
<p>The trouble starts with a real app: a few hundred strings across dozens of components, a second language next month, and new features every week after that. Here is where a coding agent tends to go wrong, what you can do about it if you stay with an agent, and when a dedicated tool is worth it.</p>
<h2>1. It only translates the files it reads</h2>
<p>An agent works through a context window. It opens the files it thinks matter, wraps the text it sees, and stops when it decides it&#39;s done. What gets missed is predictable:</p>
<ul>
<li><strong>Attributes</strong>: <code>placeholder</code>, <code>alt</code>, <code>title</code>, <code>aria-label</code>. Easy to skip because they&#39;re not between tags.</li>
<li><strong>Copy in data</strong>: arrays of feature cards, nav items, table column headers, select options defined at the top of a file.</li>
<li><strong>Strings far from the UI</strong>: validation messages, empty states, toast text in a hook.</li>
</ul>
<p>None of these break the build. They just ship in English, and you find them when a German user sends a screenshot.</p>
<h2>2. Keys drift between sessions</h2>
<p>Ask twice and you get two naming schemes: <code>header.features</code> in one session, <code>nav.featuresLink</code> in the next. The same sentence on two pages ends up under two keys, translated twice and possibly differently. Rename a key later and every existing translation for it is orphaned.</p>
<p>Keys are a contract between your code and your locale files. They need to be stable and derived the same way every time, which is exactly what a fresh prompt doesn&#39;t give you.</p>
<h2>3. Every run starts from zero</h2>
<p>An agent has no memory of what it translated last week. Ask it to &quot;translate the new strings&quot; and it either re-translates everything (more tokens, a noisy diff, reviewers re-reading text that didn&#39;t change) or guesses which strings are new.</p>
<p>What you want is a record: for each key and language, the source text it was translated from. If the source hasn&#39;t changed, keep the translation. If it has, translate again. That record is a lockfile, and it&#39;s the difference between a $0 re-run and paying for the whole app every time.</p>
<h2>4. Sentences get chopped into fragments</h2>
<p>This one is subtle:</p>
<pre><code>&lt;p&gt;You have &lt;strong&gt;{count}&lt;/strong&gt; tasks due today.&lt;/p&gt;
</code></pre>
<p>A quick fix wraps the two text pieces separately: <code>t(&quot;youHave&quot;)</code>, then the bold count, then <code>t(&quot;tasksDueToday&quot;)</code>. In English it reads fine. In German or Japanese the word order is different, and a translator who sees &quot;You have&quot; and &quot;tasks due today&quot; as separate strings can&#39;t fix it.</p>
<p>The right shape is one message with the markup and the variable inside it, in ICU format:</p>
<pre><code>&quot;tasksDue&quot;: &quot;You have &lt;strong&gt;{count, plural, one {# task} other {# tasks}}&lt;/strong&gt; due today.&quot;
</code></pre>
<h2>5. Plurals and placeholders break quietly</h2>
<p><code>{count} tasks</code> covers English. Polish has more plural forms, Arabic has six, Japanese has one. If the plural isn&#39;t written as an ICU plural, translators can&#39;t express it.</p>
<p>Placeholders have the opposite problem: a model translating <code>Thanks! We sent a link to {email}.</code> sometimes translates the variable name, drops the braces, or loses the <code>{email}</code> entirely. Nothing fails until that string renders with a blank where the address should be.</p>
<h2>6. Your product name gets translated</h2>
<p>We saw this ourselves while testing a small sample app called Tasklane. On a run where a machine-translation model handled the strings, French came back with the brand name translated as &quot;pour les enfants&quot; (for the children). Brand names, product terms and words you never want translated need to be fixed before translation, not discovered in review.</p>
<h2>7. Nobody remembers to do it next month</h2>
<p>The first pass is the visible part. The real work is every pull request after it: new strings, changed copy, a new language. With an agent, someone has to remember to ask, and has to ask the same way every time.</p>
<h2>If you stay with an agent: a checklist</h2>
<p>You can get much better results by giving the agent rules instead of a one-line request. Something like:</p>
<pre><code>Internationalize this app with next-intl.
- Process one directory at a time and list every file you changed.
- Wrap JSX text AND these attributes: placeholder, alt, title, aria-label.
- Also wrap user-facing strings in arrays/objects (labels, titles, descriptions).
- Keys: &lt;file-or-component&gt;.&lt;camelCaseOfFirstWords&gt;. Reuse an existing key if the
  same text already has one; never rename existing keys.
- One ICU message per sentence, with markup and variables inside it.
  Use ICU plural syntax for any count.
- Never translate: Tasklane, Babelize, GitHub (keep as written).
- Keep every {placeholder} exactly as in the source.
</code></pre>
<p>Then check the result with a script rather than by eye:</p>
<ul>
<li>every locale file has the same keys as the source file;</li>
<li>every <code>{placeholder}</code> in the source appears in each translation;</li>
<li>no translation is identical to the English source (a sign it was skipped);</li>
<li>no hardcoded text is left in JSX (a quick AST scan or <code>eslint-plugin-i18next</code>).</li>
</ul>
<p>And keep your own record of what&#39;s been translated, so the next run only touches new or changed strings.</p>
<h2>When a dedicated tool is worth it</h2>
<p>That checklist is most of what a localization pipeline does, written as instructions to a model that may or may not follow them. If you&#39;d rather not maintain it, this is the job <a href="https://www.babelize.co/?utm_source=devto&utm_medium=article&utm_campaign=why-not-cursor">Babelize</a> does:</p>
<ul>
<li>it parses every source file with an AST, so attributes and copy in data are found the same way every time;</li>
<li>keys are derived consistently and reused on re-runs;</li>
<li>a lockfile means only new or changed strings are translated, and billed;</li>
<li>sentences become ICU messages, and every translation is checked for lost placeholders and broken plurals;</li>
<li>a glossary keeps names like Tasklane as written;</li>
<li>auto-localize translates each push and keeps one pull request up to date, so nobody has to remember.</li>
</ul>
<p>It also works inside your agent: the Babelize MCP server gives Cursor, Claude Code and Codex these tools, so the agent calls a deterministic pipeline instead of improvising one.</p>
<p>Whichever way you go, the rule is the same: translations should arrive as a diff you review, never straight into production.</p>
---
- [All articles](https://www.babelize.co/blogs)