I'll be honest. I used to dread the i18n parts of my projects. Not because the concept is hard, but because the workflow was just... tedious. Copy strings here, paste them there, context-switch between your code and some web dashboard, wait for translations, download files, realize you forgot one string, repeat.
Last month I started using Cursor for a side project that needed Spanish and French support. What happened next genuinely surprised me, and I wanted to share the setup that's been working for me.
A Quick Confession
Before we dive in: I'm not saying this approach is perfect. There are rough edges I'll point out along the way. But compared to my old workflow of juggling JSON files manually and using Google Translate for initial drafts? Night and day difference.
What Makes Cursor Different for i18n
If you're not familiar with Cursor, it's essentially VS Code with AI baked in. I was skeptical at first ("another AI code editor, great"). But the MCP (Model Context Protocol) support is what changed things for me.
MCP lets Cursor's Claude connect to external services. Think of it like giving the AI hands to actually do things, not just suggest code. For translation work, this means Claude can:
- Actually create translation keys in your TMS
- Pull down existing translations
- Push new ones up
- Check what's missing
It's the "actually do things" part that matters. I've used Copilot for years, and while it's great at suggesting 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.
