Claude Code Skills for i18n: Automate Translation Workflows from Terminal

I've been using Claude Code for a few months now, and it's changed how I handle internationalization. Instead of context-switching between my editor, terminal, and translation dashboard, I just type a slash command and let Claude handle the tedious parts.

Here's what I've learned about building custom i18n skills for Claude Code.

What are Claude Code Skills?

Claude Code is Anthropic's CLI that brings Claude directly into your terminal. Skills are custom slash commands you define - think of them as reusable AI instructions for common tasks.

For i18n work, this is perfect. Translation tasks are repetitive and follow consistent patterns. Instead of explaining what you want every time, you create a skill once and invoke it with a simple command.

Your first skill: Finding hardcoded strings

Let's start with something simple. Create a file at .claude/commands/i18n-scan.md:

MARKDOWNCopy
1# i18n-scan
2
3Scan the current file or specified files for hardcoded strings that should be internationalized.
4
5## What to look for:
6- JSX text content between tags
7- String literals in user-facing contexts (labels, messages, titles)
8- Template literals containing user-visible text
9- Placeholder text in inputs
10
11## What to ignore:
12- console.log messages
13- Error messages for developers (unless user-facing)
14- CSS class names
15- Import paths
16- Object keys that are internal identifiers
17
18## Output format:
19For each hardcoded string found, show:
20- Line number
21- The hardcoded string
22- Suggested translation key (following namespace.section.element pattern)
23- Context about where it appears

Now when you run /i18n-scan in Claude Code, it knows exactly what to look for.

The extraction skill

This is the skill I use most. It doesn't just find strings - it actually extracts them and updates your code.

Create .claude/commands/i18n-extract.md:

MARKDOWNCopy
1# i18n-extract
2
3Extract hardcoded strings and convert them to translation keys.
4
5## Process:
61. Identify all hardcoded user-facing strings
72. Generate appropriate translation keys following naming convention
83. Update the file to use translation function (t() or equivalent)
94. Add necessary imports
105. Create or update translation file with new keys
11
12## Naming convention:
13Keys should follow `namespace.section.element` pattern:
14- `settings.profile.title` → "Profile Settings"
15- `common.buttons.save` → "Save"
16- `errors.validation.required` → "This field is required"
17
18## Framework detection:
19- If react-i18next: use useTranslation hook and t() function
20- If next-intl: use useTranslations hook
21- If vue-i18n: use $t() in templates, t() in setup
22- If FormatJS: use FormattedMessage or useIntl

Run /i18n-extract on any file, and Claude handles the entire extraction process.

Connecting to your TMS

The real power comes from integrating with your translation management system. With MCP (Model Context Protocol), Claude can interact with IntlPull directly.

Create .claude/commands/i18n-translate.md:

MARKDOWNCopy
1# i18n-translate
2
3Translate missing strings using IntlPull MCP integration.
4
5## Prerequisites:
6- IntlPull MCP server must be connected
7- Project must be configured in IntlPull
8
9## Process:
101. Use IntlPull MCP to get current project status
112. Identify keys with missing translations
123. For each missing translation:
13   - Get source text
14   - Get existing translations for context
15   - Generate appropriate translation
16   - Push to IntlPull with quality flag "needs_review"
17
18## Language handling:
19- Translate to all project languages by default
20- Or specify: `/i18n-translate spanish`
21
22## Quality control:
23- Mark all AI translations as "needs_review"
24- Include translation notes for ambiguous terms
25- Flag terms that should use glossary entries

Now /i18n-translate spanish sends missing strings for AI translation, marked for human review.

Checking translation coverage

Before deploying, I want to know what's missing. Create .claude/commands/i18n-status.md:

MARKDOWNCopy
1# i18n-status
2
3Generate a translation coverage report.
4
5## Report should include:
6- Overall coverage percentage per language
7- Namespaces with missing translations
8- Recently added keys without translations
9- Keys marked as "needs_review"
10- Potentially outdated translations
11
12## Display format:
13Table showing:
14- Language
15- Coverage %
16- Missing count
17- Needs review count
18
19Then list specific missing keys grouped by namespace.
20
21## Data source:
22- If IntlPull MCP connected: pull live data
23- Otherwise: analyze local translation files

Validation for CI

Create .claude/commands/i18n-validate.md for catching issues before deployment:

MARKDOWNCopy
1# i18n-validate
2
3Check for translation issues. Designed for CI but works locally.
4
5## Checks:
6
7### Structural issues:
8- Missing translations in non-source languages
9- Orphaned keys (exist in translations but not in code)
10- Invalid JSON/YAML syntax
11- Inconsistent nesting across languages
12
13### Content issues:
14- Empty translations
15- Placeholder mismatches ({name} in source but not in translation)
16- Suspiciously long translations (might break UI)
17- Suspiciously short translations (might be incomplete)
18- Untranslated content (same as source language)
19
20### Code issues:
21- t() calls with non-existent keys
22- Hardcoded strings in staged changes
23- Dynamic key construction (hard to track)
24
25## Output levels:
26- Error: must fix before deploy
27- Warning: should review
28- Info: for awareness
29
30## Exit codes:
31- Exit 0 if no errors
32- Exit 1 if errors found (for CI integration)

My daily workflow

Here's what it looks like in practice:

1. Start feature branch: git checkout -b feature/user-settings

2. Write code with hardcoded strings. Don't worry about i18n while building.

3. Before committing, on each modified file: /i18n-extract

4. Generate translations: /i18n-translate

5. Validate: /i18n-validate

6. Commit everything in one atomic commit

Total time added: 2-3 minutes per feature. Compare that to the hour I used to spend.

Pro tips

Be specific about your stack. Generic skills work, but stack-specific skills work better. If you're using Next.js with next-intl, create skills that understand that setup.

Build incrementally. Start with /i18n-extract and /i18n-status. Add more skills when you find yourself repeating instructions.

Version control your skills. Put .claude/commands/ in git. When teammates update Claude Code, they get your skills automatically.

Combine with project rules. In your CLAUDE.md, add i18n guidelines so Claude follows these standards even outside skill invocations.

Use MCP for superpowers. With IntlPull's MCP server, skills can create translation keys, pull translations, push updates, and trigger workflows. This turns skills from "AI suggestions" into "AI actions."

Getting started

1. Install Claude Code: npm install -g @anthropic-ai/claude-code

2. Create .claude/commands/ in your project

3. Add the i18n-extract skill from this post

4. Try it on a file with hardcoded strings

5. Iterate based on what works for your stack

The setup takes maybe an hour. The time savings compound every day.

---

Update 2026: Looking for more advanced workflows? Check out our 2026 guide on building custom translation automation commands with bulk operations, validation pipelines, and agent-based workflows.

Want ready-to-use skills? IntlPull maintains a collection of Claude Code skills for i18n. Our MCP server gives Claude direct access to manage translations from your terminal.