Greetings!

If you are tired of manually editing endless JSON files with translations and want your AI agent (Copilot, Cursor, Claude) to do it for you - this article is for you.

Today we will look at Goman.live - a tool that turns the routine of localization into magic. We will discuss why it is needed, how it saves your time, and why it is a must-have for the modern "vibe coder".

---

What is Goman.live and why do you need it?

Goman.live is not just another translator. It is a smart backend for managing your application’s content.

Imagine: you write code, and all texts - buttons, errors, descriptions - automatically appear in all required languages, taking into account the context and style of your project. No manual copying to Google Translate, no errors in keys, and no "broken" localization files.

The service works in two modes:

1. Autopilot (via MCP): You simply ask your AI agent in the IDE to "add a button", and everything happens by itself.
2. Control Center (Web Editor): A powerful interface for manual tuning, quality checking, and managing complex contexts.

---

Who really needs this?

Goman.live was created to remove pain from the development process:

• 🚀 Vibe Coders (AI-Native Developers): You are used to working fast. Context switching to edit JSON kills the flow. Goman allows you not to leave the IDE.
• 👨‍💻 Pet Project and Startup Developers: Want to launch immediately in 10 languages? With Goman, it takes as much time as for one.
• 👩‍💼 Teams: A single source of truth for all texts. The developer doesn’t wait for the translator, the translator doesn’t break the JSON.

---

MCP: Automation of localization in IDE

This is the main feature. MCP (Model Context Protocol) allows you to connect Goman directly to your Copilot or Cursor.

🎬 See it in action: Adding Spanish language support

How does it look in practice? Instead of opening 5 files (en.json, de.json, es.json...), searching for the right key, and inserting text, you write in the IDE chat:

"Scan the open file and create translations for all text strings."

Or even for a whole module:

"Localize all components in the src/features/auth folder. Save keys in the auth namespace."

You can ask to localize the entire project at once, but for better control, it is recommended to do it in parts.

What happens under the hood:

1. The agent checks if such a key exists (to avoid duplicates).
2. Generates translations into all languages supported by the project.
3. Saves them to the database.
4. You can immediately use t('actions.save') in the code.

It is important to note: besides the translations themselves, the system stores context for each key (this works both via MCP and via the Editor). Thus, the agent and you can always know where a specific localization is used and what it means.

This saves hours of routine work and allows you to focus on application logic, not dictionaries.

Full Set of Tools (MCP Tools)

The MCP server gives your agent full control over the localization process. The service covers the entire lifecycle of working with texts:

1. Project Discovery (Discovery)

• get_active_languages: The first thing the agent does is check which languages are active in the project. This guarantees that translations will be created only for the required locales.
• get_namespaces: Shows the project structure (list of files/namespaces) so the agent knows exactly where to save new texts (e.g., in common or auth).

2. Search & Verification

• search_localizations: Powerful search by keys and values. The agent can find all buttons with the word "Cancel" or check how the word "Save" is translated elsewhere to maintain consistency.
• get_localization_exists: Precise check of a specific key. Allows avoiding duplication and overwriting of existing important texts.

3. Content Management (Management)

• create_localization: The main tool. Creates or updates translations. Understands context and can add translations immediately to all active project languages in one request.
• delete_localization: Allows deleting obsolete or erroneous keys, maintaining cleanliness in the project.

This set of tools turns your AI agent into a full-fledged localization manager.

Ready-made Templates (Prompts) for a Quick Start

To avoid wasting time writing instructions for AI, the system already has a set of proven prompts for typical tasks. They are available exclusively via MCP and are ready for use by your agent:

• init-project: Full localization setup from scratch. Helps choose the project structure, scans files, and creates the first keys.
• localize-component: Just insert the component code (React, Vue, etc.), and the agent will find all texts, create keys, and even show how to change the code.
• localize-folder: The same, but for entire folders. Ideal for mass localization.
• add-language: Want to add Polish? This prompt will take all existing English keys and translate them into the new language.
• check-coverage: Project audit. Shows which keys are missing in which languages (e.g., "5 translations missing in ru").
• localization-audit: Deep analysis. Finds keys that are no longer used in the code and suggests deleting them.

Just choose the necessary template, and the system itself will substitute the optimal settings for a high-quality result.

Context and Prompt Management in IDE

This function links settings in the web interface with the developer’s working environment. The system provides a Prompt Editor, which allows creating specialized instructions for AI agents.

This solves the "blank slate" problem when the model needs the context of the task explained every time.

What the editor allows you to do: The main function is the creation and editing of the prompts themselves. It is through them that you manage the context in your IDE or agent. You write the rules of the game once, and the agent starts following them.

It is important to note: this works not only for translations. You can create prompts for any development tasks - from refactoring to writing tests.

Usage examples:

• For coding: "Use arrow functions, avoid any, write comments in JSDoc format, and always cover new code with tests."
• For interface: You can set a strict rule: "Translate as briefly as possible so the text fits into buttons, use Apple HIG terminology."
• For marketing: "Write emotionally, address the user as ‘you’, add appropriate emojis."
• For technical documentation: "Maintain an official style, do not translate specific terms (e.g., ‘middleware’, ‘token’), formulate thoughts precisely and dryly."

The user simply selects the necessary prompt from the list in Copilot or Cursor, and the agent instantly switches to the required mode of operation.

---

Editor: Full Control Over Quality

If MCP is speed, then the web editor is precision.

Here you can:

• See the full picture: All languages side by side.
• Edit context: Add a description for AI so it understands that "Home" is a page, not a building.
• Fix nuances: If AI slightly missed the style, you can quickly fix it manually or ask to redo the variant.

This is ideal for marketing texts, landing pages, and important messages where every word matters.

Prompts: Your Personal Style

Why do AI translations sometimes look "machine-like"? Because the model doesn’t know your context. In Goman.live, you create Prompts - a set of rules for your project.

This is a replacement for outdated "glossaries". You can tell the model:

• "Address the user as ‘you’"
• "Do not translate the brand name ‘SuperApp’"
• "Use a cheerful, informal tone"

AI Assistant for Prompts

Don’t know how to write a prompt correctly? The built-in AI chat will help formulate ideal instructions for the model so the result is exactly as you expect.

Prompt Storage and Versioning

You can store up to four (currently four) versions of a single prompt and switch between them in one click.

This is very convenient if you want to experiment with formulations or translation rules. Prompt versioning, when used properly, can significantly reduce token consumption. It can also be useful when testing and searching for the most suitable prompts - a prompt testing system has been added to the service - you can immediately run requests for execution and get results.

Collaboration

If you are not working alone - just add a colleague’s email.

They will get access to your project, and you can work together on localizations and translations. Restrictions are only by tariff plan. Tokens for translation are taken from the owner’s account - that is, the one who "shared".

---

Supported Languages

There is no full list of languages in the service - and that’s good.

Models are used that can work with dozens and hundreds of languages, so there are effectively no restrictions.

Translation quality depends on the text itself, the prevalence of the language, and whether there are similar translations in your database.

Translations via the editor often turn out better than via standard tools because context and previous results are taken into account.

And if you work via MCP, the quality depends on the model your agent uses - for example, Claude, GPT, etc.

---

Quality Control: Trust, but Verify

AI is a powerful tool but not perfect. Therefore, Goman.live has built-in insurance mechanisms:

1. Automatic Syntax Check: The service watches so AI doesn’t break variables (e.g., {{name}}) or HTML tags.
2. Highlighting Suspicious Places: In the editor, you will see warnings if the translation looks uncertain.

You always have the last word. The service proposes - you approve.

---

Limitations and Features

Since the service runs on LLMs, it has its own features.

First of all - this is the context size: the model can process only a certain amount of information at a time (on average about 8–10 thousand tokens).

If the text is too large, it is better to divide it into logical parts - this way the model better understands the structure and context, and translations come out more accurate.

When using RAG, the context may also be incomplete because separate pieces of text are stored in it and search occurs through it.

Therefore, it is better to translate in small blocks and avoid overloading the model.

This is not a disadvantage, but rather a feature of LLM operation; they simply must "understand" the text within their context window.

But this allows achieving stable results and easily processing translations.

---

About Tokens and Cost

The principle of operation is honesty.

• Via MCP: You use your own API key (Copilot, Cursor, OpenAI), so Goman.live does not charge any additional fees for tokens. It is effectively free from the service side.
• Via Editor: The service’s capacities are used, so internal tokens are deducted.

How to get a discount?

A referral program is active: bring a friend and get up to 90% discount. You can contact goman.live.service@gmail.com if you want to learn more.

---

About Data Retention

All your data is stored on our own servers.

A dump is made every 6 hours, and information is not transferred to third parties except for models (LLMs) that process translations. Data after application deletion may be stored for some time - done for the possibility of restoring them upon personal request. You can also export localizations in the form offered in the service at any time. Uploading data is possible via MCP, via a form (one record at a time), or immediately many from a file in the required format.

---

About Cooperation

The project team is open to new ideas and cooperation.

If you have a service or business that can be integrated with Goman.live, or if there is interest in the project - you can contact the developers.

Creation of custom plans, API integrations, and even separate solutions for specific needs is possible.

---

Additional Functionality

Goman.live is not just localizations.

The service allows testing prompts, viewing results, saving them in different versions, and even working in a team. This is described in more detail in the service documentation

---

What’s Next

Work is underway on the following things:

• improving prompt integration with GitHub Copilot, Cursor, and other IDEs,
• choice of translation model and use of own API keys,
• improving RAG and automatic update of localizations,
• and many more ideas that will make working with translations even more convenient.

---

Summary: Why is it worth trying?

If you want to create global products but don’t want to waste your life on spreadsheets with translations - Goman.live is for you.

1. Speed: Localization becomes part of writing code, not a separate stage.
2. Quality: AI knows context and style better than Google Translate.
3. Convenience: Manage everything right from your favorite IDE.

👉 Try it yourself at goman.live and feel the difference. Your users will say "Thank you" (in their native language 😉).