Home Getting Started

Getting Started

globalize.now
By globalize.now
7 articles

How globalize.now works — overview

globalize.now makes your app multilingual in three steps. Already have i18n set up? If your codebase already has locale files and an i18n library configured, the agent detects that and connects your existing setup to auto-translate on push instead of rebuilding anything. See "I already have i18n. What does globalize.now do?" Free to start. Setup is free. You get a €5 translation credit when you sign up, enough to translate a small-to-medium app across multiple languages before you need to add billing. Step 1 — Install the skills Run one command in your terminal from your project root: npx skills add --all globalize-now/globalize-skills This installs the globalize.now skills into your AI coding agent. It auto-detects your agent (Claude Code, Cursor, Codex, and others). To target one explicitly, add -a, for example -a claude-code, -a cursor, or -a codex. The skills are a localization playbook your agent reads. Nothing in your codebase changes yet. Step 2 — Ask your agent to set it up Use a strong model for this step. Claude Opus handles messy, vibe-coded codebases reliably. Smaller models tend to miss strings or generate inconsistent key names. Open your agent and ask it to set up localization: Set up i18n for my project The globalize-guide skill takes over. It inspects your stack, recommends a library (Lingui for React and Vite, next-intl for Next.js App Router), and shows you a short plan before it changes a single file. You review the plan and give the go-ahead. Then it installs the library, wraps your hardcoded strings in translation keys, and generates locale files for the languages you chose. It runs in stages with progress you can follow, and it resumes where it left off if a session is interrupted. A small-to-medium app takes roughly 30 minutes. Don't cancel mid-run. Step 3 — Connect your repo for translation Ask your agent to connect the project: Connect globalize.now to my repo The globalize-now-cli-setup skill installs the Globalize CLI, signs you in, creates your translation project, and connects your GitHub or GitLab repo. From this point on, every time you push new code, globalize.now detects new strings, translates them, and opens a pull request with updated locale files. You review and merge. No other manual steps, ever. What you get at the end - All UI strings extracted and translated into your chosen languages - Locale files committed to your repo (you own the files, no vendor lock-in) - A language switcher in your app - Automatic sync on every future push Verify it worked After setup, confirm the output looks right before you call it done. See the verify setup article. Where to go next - Before you start — what to expect - What does globalize.now actually do to your code? - What project types and frameworks are supported?

Last updated on Jun 26, 2026

Before you start: what to expect

Three things to know before you run the first command: what it will do to your code, how long it takes, and how to set up your repo. Create a branch first Always start on a fresh branch. Setup and conversion make significant changes to your codebase — rewrites component files, adds library config, creates locale files, may touch your root layout. You want all of this isolated from main so you can review the diff and merge when you're satisfied. git checkout -b feat/i18n-setup git push -u origin feat/i18n-setup Then push your latest changes so globalize.now can read them: git status # confirm nothing uncommitted git push # push any local commits Connect globalize.now to this branch. If you run setup directly on main, all agent changes go straight to your main branch with no staging area. How long it takes | Step | Typical time | | --- | --- | | Install skills (npx skills add --all globalize-now/globalize-skills) | < 1 minute | | Agent setup and conversion (Set up i18n for my project) | 15–45 minutes | | Connect repo to globalize.now | 2–5 minutes | | First translation job | 2–10 minutes | Total: roughly 30 minutes for a small-to-medium app. Large codebases (100+ components) take longer. Don't cancel mid-conversion The conversion stage, when the globalize-guide skill wraps your strings, can take 30–45 minutes on a large codebase. This is normal. Do not cancel the session mid-way — interrupting it leaves your codebase in a partial state. Check your editor's source control panel to confirm files are still being modified if you're unsure it's working. If you need to scope the conversion, tell the agent upfront: Convert only the /src/components directory first After setup is complete Review the diff, test your app locally, then open a pull request from your branch to main. Merge when you're happy with the output. Future runs (adding new strings) are much faster — the agent only processes what's changed.

Last updated on Jun 26, 2026

What does globalize.now actually do to your code?

Two questions most users have before starting: what does the install command do, and will it break anything? What the install command does npx skills add --all globalize-now/globalize-skills installs the globalize.now skills into your AI coding agent. That's it, nothing in your codebase changes. The command copies a set of skill files into your agent's skills directory: .claude/skills/ for Claude Code, .agents/skills/ for Cursor, Codex, and Copilot. These are plain text instructions that tell the agent how to handle i18n: which library to use, how to extract strings, how to name keys, how to structure locale files. If the CLI can't auto-detect your agent, it asks which one to install to, or you can name it with -a (for example -a claude-code). After installing, you set things up by asking your agent in plain language: Set up i18n for my project To wire up auto-translation later, you ask it to connect the project: Connect globalize.now to my repo These are things you type into your agent, not output the agent generates. Will it change your code permanently? No. Every change goes into the branch you created before starting, not directly to main. When you ask the agent to set up i18n, the globalize-guide skill first shows you a plan and waits for your go-ahead. Once you approve, it modifies files in your local branch: it rewrites components to use translation keys instead of hardcoded strings, adds locale files, and updates configuration. All of this happens in a branch. At the end, you review a diff like any other pull request. You can inspect every change, test locally, and only merge when satisfied. What if something looks wrong? - Don't merge. Close the branch and nothing reaches main. - Revert the branch. git checkout main && git branch -D feat/i18n-setup. Main is untouched. - Fix specific files. Edit them in the branch before merging. The agent doesn't force-push to main, that's an explicit design constraint. What about auto-translate? When globalize.now translates your strings on every push, it creates a pull request with updated locale files. Same model, you review it, you merge it. The app never commits directly to main. Where do the skill files go? Skills install locally to your agent's skills directory: .claude/skills/ for Claude Code, .agents/skills/ for Cursor, Codex, and Copilot. They're project-scoped, so one repo doesn't affect another, and they're plain text files you can read in any editor. If you want to review them before installing, browse the skills on GitHub at globalize-now/globalize-skills and copy the folders in manually, or run the command with --copy instead of the default symlink.

Last updated on Jun 26, 2026

You're set up! here's how to verify it worked

The setup is done. Here's what success looks like and how to confirm everything is working before you call it done. What your repo should look like now After setup completes, your repo should contain: New files added: /messages (or /locales — depends on your i18n library) en.json ← your source strings, all extracted es.json ← placeholder file, empty until translated de.json fr.json Modified files: - Your component files — hardcoded strings replaced with t("checkout.submit") calls - Root layout or app entry point — i18n provider wrapped - i18n library config file — new, auto-generated If you don't see locale files in your repo, the conversion step didn't complete. See the setup stalled troubleshooting article and re-run. Check that the conversion looks right Open a few component files and confirm the strings were extracted. Look for: - t("some.key") calls replacing what used to be inline text - Consistent key naming (e.g. checkout.submit_button, not a mix of styles) - The en.json file contains real readable strings, not garbled output If you see hardcoded strings still in the file, the agent missed them. Ask your agent to wrap the strings it missed (for example: "wrap the remaining hardcoded strings"). It picks up what was missed without duplicating work. Test the language switcher locally 1. Run your dev server: npm run dev (or your usual command) 2. Open the app in your browser 3. Switch languages using the switcher 4. Confirm UI text changes — it won't be translated yet (just the keys), but switching shouldn't break the app If the switcher isn't visible, ask your agent: Add a simple language switcher to my app If switching languages crashes the app, chat with us at globalize.now — it usually means the i18n provider wasn't wrapped correctly during setup. Trigger your first translation push git add . git commit -m "test: trigger first globalize.now translation" git push Within 2–5 minutes you should see a new pull request from globalize.now with translated locale files. Open the PR and check that the locale files contain actual translated text and the languages you selected are all present. If no PR appears after 10 minutes, check your globalize.now dashboard for the job status. Merge and you're done Review the translation PR, merge it, and your app is now serving real translated content. From this point on, every push you make automatically triggers the translation pipeline. No further manual steps.

Last updated on Jun 02, 2026

I already have i18n. What does globalize.now do?

If your codebase already has next-intl, react-i18next, i18next, or @lingui/* wired up, globalize.now skips the setup scaffold and goes straight to sync mode. No language switcher injection. No locale file restructure. No destructive changes. The short version: install the skills, ask your agent to connect the project, and on every push to main globalize.now diffs your source-language file against the other locales. New keys get translated. A PR lands with updated locale files. You review and merge. How it runs 1. Install the skills: npx skills add --all globalize-now/globalize-skills 2. Ask your agent to connect: Connect globalize.now to my repo The globalize-guide skill inspects your repo first. When it sees an existing i18n setup, it proposes connect-only (sync) mode and shows you the plan before doing anything. You confirm, and the globalize-now-cli-setup skill connects your GitHub or GitLab repo. Your existing locale structure is read, not rewritten. This is auto-detected from signals in your repo (an i18n library in package.json, a messages/ or locales/ folder, an existing source-locale file). If at least two are present, you're treated as already-internationalized. If the agent's plan looks like a full from-scratch setup instead of connect-only, don't approve it. Tell it the project already has i18n, and it switches to sync mode. See the article below. Where to go next - Detection signals + what we skip — the full list of dependencies and folders we read, and exactly what we don't touch in sync mode. - The setup plan looks bigger than expected — what to do if the agent proposes a full setup on an already-internationalized repo. - How globalize.now fits into your stack — globalize.now plus your i18n library, who does what.

Last updated on Jul 03, 2026

I build with Lovable. How do I set up globalize.now?

Yes, globalize.now works with Lovable. You install one skill, connect the globalize MCP, then ask Lovable to do the rest. Every push after that stays translated. What you need first - A Lovable project connected to GitHub. - A globalize.now account. Free signup includes €5 of starting credit, no card. - Workspace owner or admin in Lovable, needed to add a skill once for the whole workspace. Setup 1. Connect your Lovable project to GitHub. In the Lovable editor, open the + menu in the chat, then GitHub, then Connect project. Skip if it is already connected. 2. Add the lovable-i18n skill by uploading the zip. Download the skill: https://globalize.now/lovable-i18n.zip Then in Lovable open Skills, click Add, and upload the .zip. You do this once per workspace; it is free and does not use credits. Lovable's "Import from GitHub" for skills is temporarily broken, so upload the zip instead. When Lovable fixes that bug, Import from GitHub will work again. 3. Add the globalize MCP. In Lovable open Connectors, then Custom MCP, and add: https://api.globalize.now/mcp Authenticate with an API key. Create or copy one from the MCP tab of your globalize.now dashboard. Lovable connectors use API-key auth, not browser sign-in. 4. Ask Lovable to run it. Paste into the Lovable chat: Use the lovable-i18n skill and the globalize MCP to set up i18n and translate my app. Lovable installs Lingui, scaffolds a PO catalog per locale, wraps your hardcoded strings, and adds a language switcher. The MCP connects your repo and translates. Review the diff and merge. 5. Keep building. Every push opens a translation PR with updated catalogs. Merge it and your app ships translated. There is no separate dashboard step and nothing to do between releases. Building in Cursor or Claude Code instead? Same skills, different install. In the connected repo, run: npx skills add globalize-now/globalize-skills --all Then add the same MCP and ask your agent to set up i18n and translate. Troubleshooting - No Skills page in Lovable? You need workspace owner or admin access. Ask your workspace owner to add the skill once; it then applies to every project. - Import from GitHub fails? That is the known Lovable bug. Upload the zip above instead. - Where is the MCP API key? In your globalize.now dashboard, MCP tab. Generate it there; it is shown once.

Last updated on Jul 11, 2026

MCP, CLI, or skills — which one do I need?

Globalize gives you three ways to reach the same backend. They do different jobs, and most people use more than one. Here's how they fit together. The skills — they change your code npx skills add globalize-now/globalize-skills installs a playbook into your coding agent (Claude Code, Cursor, Codex). The agent then does the part that touches your codebase: it detects your framework, installs the right i18n library, finds your hardcoded English text, and turns it into translation keys and a source locale file. This is the only piece that edits your components. Use the skills when your app isn't internationalized yet, or when you add new UI and want it wired up correctly. If your agent is already connected to the MCP server, you don't have to install the skills by hand. The server exposes an install-skills prompt (a slash command in Claude Code, Cursor, Windsurf, or Codex) that installs the whole skill set in one step. From then on they auto-trigger on requests like "set up i18n" or "translate my app". The MCP server — it manages localization and translates files The MCP server connects an AI agent to your Globalize account. Through it, the agent can create projects, add languages, translate locale files, connect your GitHub repo, and manage your glossary and style guides. It works on locale files and project settings — it does not edit your source code. Use the MCP when you want to drive Globalize from inside Claude, Cursor, or another agent without leaving your editor. The CLI — the command layer underneath The globalize CLI is the command surface the skills call for account, project, and repository setup. You rarely run it directly; the skills handle it for you. It's there if you want scripted, non-interactive control. A typical first run 1. Skills internationalize your code and produce messages/en.json (or your framework's equivalent). 2. MCP or CLI creates the project, translates that file into your target languages, and connects your repo. 3. From then on, every push that adds new English text triggers a translation pull request automatically. The short version If your question is "why won't the MCP internationalize my app?" — that's expected. The MCP manages and translates; the skills change your code. Run the skills first, then let the MCP take it from there.

Last updated on Jul 10, 2026