How to localize an app Claude Code generated, without leaving the agent

The best way to localize an app Claude Code generated is to stay in Claude Code: install a localization skill, let the agent internationalize the codebase, and let infrastructure keep every language in sync from there. globalize.now is AI-powered localization infrastructure built for exactly this loop. It extracts hardcoded strings into translation keys, generates locale files, and returns translated languages as pull requests on every git push. This guide walks through the whole thing, from an English-only repo to a merged multilingual PR.

Why is your Claude Code app English-only?

Because Claude Code, like every coding agent, writes user-facing copy as literal strings. That is the shortest path to a working feature, and nothing in a default prompt asks for translation keys. By the time the app works, English is hardcoded into hundreds of components, and plurals and dates are handled with string concatenation that only makes sense in one language.

The tempting fix is to ask the agent to "translate the app to German." That produces a second hardcoded language: duplicated components or a pile of ternaries, and every future feature doubles the work. We covered this failure mode in how to localize an AI-generated app. Translation without internationalization is how i18n debt compounds.

What is the best way to localize an app Claude Code generated?

Run the localization workflow inside the agent that built the app: a skill teaches Claude Code the internationalization procedure, and infrastructure handles translation and sync after every push. Skills are Anthropic's supported extension format for Claude Code, folders of instructions the agent loads when a task matches, as documented in the Agent Skills docs. They are also portable: the open skills CLI from Vercel installs skill packages across Claude Code, Cursor, Codex, and dozens of other agents, so the same workflow travels with whatever agent you use.

This is a different shape from most localization tooling. Established platforms have added AI features and agent connectors on top of a workflow that still centers their dashboard: your strings live in their system, and the agent is a client of it. Agent-native localization inverts that. The work happens in your repository, the agent does the internationalization, and globalize.now does the translation and sync. There is no separate content database to keep aligned with your code, because the code is the database.

How do you localize a Claude Code app, step by step?

The full loop is five steps, and the agent does the heavy one.

1. Install the skills.

   npx skills add globalize-now/globalize-skills

   Add --all if you want the skills available to every agent on your machine, not just Claude Code.
2. Ask Claude Code to internationalize the app. The skill has it inspect the repo first: which framework, which strings are user-facing, whether any i18n setup already exists. It proposes a plan, the library, the key structure, the locale-file layout, and waits for your approval before touching code.
3. Connect the repository to globalize.now so pushes trigger translation. The developer setup is one connection, and builders working in AI tools get the same loop without touching a terminal beyond step 1.
4. Push. New and changed strings come back translated, as a pull request you review like any other code change.
5. Merge. Adding another language later is a config change, not a project.

On a real production monorepo, an agent run through this workflow internationalized the codebase and produced five languages in about 30 minutes. Your timing varies by project size, but step 2 is where a week of manual refactoring collapses into an agent session.

What does the agent actually change in your code?

It converts literal strings into translation calls and generates the locale files the runtime needs. Concretely: it picks or detects an i18n runtime library (i18next, next-intl, or Lingui, depending on your stack), replaces hardcoded JSX text with t() calls or message components, generates keys with sane names, and writes the source-language locale file. Plurals get real ICU forms instead of count + " items".

globalize.now does not replace the runtime library, and it does not translate by hand-off to some external queue. It sits one layer up: the infrastructure that generates and maintains the keys and locale files your runtime consumes. If you already have i18next or next-intl wired, the skill keeps your existing keys and structure and takes over from where you are.

What happens on the next git push?

Every push after setup triggers translation of whatever changed, and the updated languages arrive as a pull request. No export step, no import step, no queue in a separate tool. Review happens where engineers already review things: the diff.

That is the whole operating model. Set it up once, auto-sync on every git push, no manual intervention required. The failure mode of AI-built apps, where the agent ships features faster than any localization process can follow, becomes irrelevant, because the localization process is attached to the same push the feature ships on.

Do you need an MCP server or a dashboard for this?

No. MCP connects an agent to an external platform; a skill teaches the agent to do the work where the code lives. Several localization products now offer MCP servers, which is a real improvement over copy-pasting into a web editor, but the strings and their state still live in the platform on the other end of that connection, and you still reconcile the two.

With the skill-plus-push loop there is nothing to reconcile. Locale files live in git, translations arrive as commits, and rollback is git revert. We wrote about why this pattern is spreading in Claude Code skills are becoming the localization standard. Both approaches beat the dashboard era; the difference is where your source of truth sits.

What does localizing a Claude Code app cost?

globalize.now is €20 per month per workspace, which includes over 4,000,000 characters (about 600,000 words) of translation per month, then token-based usage at the same per-character rate above that. One plan, no tiers, no per-seat charges, no per-language charges. Unlimited languages, including RTL. A typical SaaS with around 10,000 translation keys across 5 locales lands comfortably inside the included volume.

Signup comes with a €5 translation credit and no card, which covers roughly a million characters. Enough to run the full loop on a real app before paying anything.

Your app is already built. Localizing it is one skill install and one push away.