Voy a ser sincero. Solía temer las partes i18n de mis proyectos. No porque el concepto sea difícil, sino porque el flujo de trabajo era... tedioso. Copiar cadenas aquí, pegarlas allí, cambiar de contexto entre el código y algún panel web, esperar a las traducciones, descargar archivos, darse cuenta de que se olvidó de una cadena, repetir.
El mes pasado empecé a usar Cursor para un proyecto paralelo que necesitaba soporte en español y francés. Lo que sucedió después me sorprendió genuinamente, y quería compartir la configuración que me ha estado funcionando.
Una Confesión Rápida
Antes de sumergirnos: No estoy diciendo que este enfoque es perfecto. Hay asperezas que señalaré por el camino. Pero en comparación con mi antiguo flujo de trabajo de hacer malabares con archivos JSON manualmente y el uso de Google Translate para los borradores iniciales? Hay una diferencia de la noche al día.
Lo que hace diferente a Cursor para i18n
Si no estás familiarizado con Cursor, es esencialmente VS Code con IA incorporada. Yo era escéptico al principio ("otro editor de código AI, genial"). Pero el soporte MCP (Model Context Protocol) es lo que cambió las cosas para mí.
MCP permite a Cursor's Claude conectarse a servicios externos. Es como darle a la IA manos para hacer cosas, no sólo sugerir código. Para el trabajo de traducción, esto significa que Claude puede:
- Crear claves de traducción en tu TMS
- Extraer traducciones existentes
- Subir otras nuevas
- Comprobar lo que falta
Lo que importa es la parte de "hacer cosas de verdad". He utilizado Copilot durante años, y mientras que es grande en la sugerencia t('some.key'), it can't actually create that key anywhere.
My Old Workflow (The Painful One)
Here's what adding a new feature with translations used to look like for me:
- Write the component with English strings
- Realize halfway through I should extract them to translation keys
- Open my translation JSON files in another tab
- Spend way too long coming up with key names (is it
button.submitorform.submitButton?) - Add the English values, copy them to each language file
- Switch to our TMS dashboard in the browser
- Create the same keys there (yes, again)
- Wait for the translation team or run machine translation
- Download the translated files
- Test the feature and discover I missed three strings
- Curse under my breath and repeat the whole dance
I timed myself once. Adding i18n support to a 200-line component took me 45 minutes. The actual code changes? Maybe 5 minutes. The rest was pure overhead.
The New Workflow
Now I just tell Claude what I want. Here's a real example from last week:
I had a checkout component with hardcoded strings. Selected the code, opened Claude (Cmd+L), and typed:
"Extract the hardcoded strings here to translation keys using react-i18next. Use the checkout namespace."
Claude updated my component AND created the keys in IntlPull. The English values were already there. I asked it to translate to Spanish and French, waited about 30 seconds, and everything was synced.
That same task that used to take 45 minutes? Maybe 3 minutes now. And honestly, most of that was me reviewing Claude's work.
Setting This Up
Alright, let's get into the actual setup. Fair warning: MCP is still relatively new, so expect some quirks.
Installing the MCP Server
You'll need Node.js installed (I'm on v20, works fine). Install the MCP server globally:
npm install -g @intlpullhq/mcp-server
Configuring Cursor
This part tripped me up the first time. In Cursor:
- Open Settings (Cmd+, on Mac)
- Find MCP Servers
- Add the @intlpullhq/mcp-server with your API key
You can also edit ~/.cursor/mcp.json directly if you prefer that approach. I ended up doing that because the UI was a bit finicky for me.
Verifying It Works
Open Claude chat in Cursor (Cmd+L) and ask something like:
"Can you check my IntlPull connection and list my projects?"
If you see your projects listed, you're good.
Workflows That Actually Help
Extracting Strings from Existing Code
This is probably my most-used workflow. Select a component, tell Claude:
"Extract these hardcoded strings to translation keys and update the component to use react-i18next"
What I like: Claude picks reasonable key names and structures them logically.
What to watch for: Sometimes it gets creative with namespaces. I always specify the namespace I want now to avoid cleanup later.
Translating Missing Content
When you've added new strings in English and need translations:
"Translate all missing strings to Spanish and French"
This one works pretty well. The translations are decent for most UI text. For anything nuanced (marketing copy, legal text), I still recommend human review.
Adding a New Language
Had a client request German support mid-project. Instead of spending an afternoon on it:
"Add German to the project and translate all existing strings"
It handled everything: updating the IntlPull project, running translations, the whole thing. Saved me probably 2-3 hours.
Finding Long Translations
This one's more subtle but super useful. German and Finnish translations tend to be longer than English. I've asked:
"Show me all translations that might be too long for typical UI buttons"
Claude looked at the keys, identified ones likely used in buttons based on naming patterns, and flagged a few German translations that were 30+ characters. Helped me avoid a layout bug before it hit production.
Things That Don't Work Great (Yet)
I want to be upfront about the limitations:
Complex pluralization: Claude handles basic plurals fine, but languages like Arabic with their six plural forms? You'll want to double-check those.
Highly contextual translations: If a string could mean different things in different contexts (like "Save" as a verb vs. as a noun), the AI might pick the wrong one. Adding context descriptions helps.
Large batch operations: I tried renaming 200+ keys at once. Cursor started lagging and I had to break it into smaller batches. Keep operations under 50 keys or so for smooth sailing.
Offline work: Obviously needs an internet connection. If you're on a plane a lot, the traditional JSON file workflow still has its place.
Tips from Trial and Error
After a few weeks of daily use, here's what I've learned:
Be specific about naming conventions upfront. Tell Claude: "When creating keys, use the format page.section.element" before you start. Saves refactoring later.
Always review before pushing. Ask "Show me all changes before pushing to IntlPull" to see what's going to happen. I caught a few weird key names this way.
Use translation branches for features. If you're working on a big feature, create a translation branch first. Keeps your main translations clean while you iterate.
Add context for human translators. Even if AI handles the initial translation, your human translators will eventually review things. Context descriptions make their job easier.
Comparison to Other Setups
I've tried a few different approaches:
Plain VS Code + JSON files: Still works, just slow. No shame in it if your project is small.
WebStorm's built-in i18n: Decent extraction tools, but no AI translation. Good for teams who don't want AI in their workflow.
Dedicated TMS web interfaces: Fine for translators and PMs, painful for developers who live in their IDE.
Cursor + MCP: Best developer experience I've found, but requires comfort with AI tools and some setup time.
Quick Reference
Once you're set up, here are prompts that work well:
For project stuff:
"List my translation projects""Switch to project mobile-app"
For managing keys:
"Create a key errors.network with value 'Network error'""Find all keys containing 'button'"
For translations:
"Translate missing keys to Spanish""Show translations for the checkout namespace""Pull latest translations"
Teaching Your AI Assistant About i18n
Here's something that leveled up my workflow even more: giving the AI context about how I want translations handled. Most AI-powered editors support some form of project-specific instructions.
Cursor Rules (.cursorrules)
Create a .cursorrules file in your project root:
# i18n Guidelines
When working with translations:
- Always use react-i18next for this project
- Namespace format: feature.section.element (e.g., checkout.form.submitButton)
- Never hardcode user-facing strings
- Use IntlPull MCP for key management
- For plurals, use ICU message format
- Keep key names in English, values localized
Claude Code (CLAUDE.md)
If you're using Claude Code CLI, add to your CLAUDE.md:
MARKDOWN1## i18n Workflow 2- Use IntlPull for translation management 3- Run `npx @intlpullhq/cli upload` after adding new keys 4- Translation keys follow: namespace.section.element 5- Always add context descriptions for translators
You can even create a custom slash command. Add to your Claude Code config:
JSON1{ 2 "skills": [{ 3 "name": "translate", 4 "description": "Translate missing strings", 5 "prompt": "Use IntlPull MCP to find and translate all missing strings to ${language}" 6 }] 7}
Then just type /translate Spanish and watch it work.
Windsurf (.windsurfrules)
Similar concept:
When handling internationalization:
1. Extract hardcoded strings to translation keys
2. Use IntlPull MCP for key management
3. Follow the project's naming conventions
4. Add descriptions for context
VS Code Copilot (.github/copilot-instructions.md)
MARKDOWN1# Translation Guidelines 2- Use i18next for all user-facing text 3- Create keys via IntlPull when available 4- Format: feature.component.element
The beauty of these instruction files is that they persist across sessions. Every time the AI helps you with code, it already knows your i18n preferences.
Final Thoughts
I'm not going to pretend this setup is for everyone. If you're working on a tiny project with one language, this is overkill. If your company has strict policies about AI tools, you'll need to navigate that first.
But for indie developers, small teams, or anyone who's tired of the traditional i18n dance, this workflow has genuinely changed how I work. The cognitive load of context-switching is gone. I stay in my editor, stay in my flow, and translations just... happen.
If you want to try it yourself, IntlPull has a free tier that includes MCP access. Cursor is also free for basic use. The setup takes maybe 15 minutes if you hit no snags.
The combination of MCP tools + AI instructions means your editor actually understands your i18n workflow. It's not just autocomplete anymore; it's a teammate that knows your conventions and can execute on them.
Worth experimenting with, especially if you've got a new project starting soon.
