Localization Rules to Locale Adaptation Example Prompt

This prompt is designed for localization engineers and AI builders who need to convert written style guides, glossaries, and locale-specific rules into compact, high-signal few-shot examples. The core job-to-be-done is behavioral teaching: instead of embedding hundreds of tokens of procedural instructions about date formats, tone registers, and forbidden terms, you provide 3–5 demonstration pairs that show the model exactly what source-to-target adaptation looks like for a specific locale. The ideal user has a documented localization rulebook and needs to produce consistent, testable adaptation behavior across many content pieces without manually rewriting each one.

Use this prompt when you have already-translated or source-language content that must be adapted to meet locale conventions—for example, converting US English marketing copy to follow Japanese business tone norms, or adapting a French technical manual to match Canadian French terminology preferences. The prompt works best when your localization rules are stable and well-documented, and when the adaptation task is about surface-level conventions (formatting, terminology substitution, tone register) rather than deep semantic rewriting. You should have at least 3–5 representative source-target pairs ready to validate the generated examples against your style guide. Do not use this prompt for direct machine translation tasks where a dedicated translation model or API is the right tool; this is an adaptation layer that sits on top of already-translated content.

Before implementing, confirm that your localization rules can be demonstrated through examples rather than requiring exhaustive enumeration. If your style guide contains hundreds of context-dependent rules that cannot be captured in a handful of demonstration pairs, consider whether fine-tuning or a rule-based post-processing layer would be more reliable. The next step after generating your examples is to run them through a validation harness that checks for locale consistency, terminology accuracy, and format compliance against your original style guide—never ship locale adaptation examples without automated eval checks and human review for high-visibility content.

This template is designed to transform a set of localization rules—such as style guides, terminology maps, and formatting conventions—into concrete, few-shot demonstration pairs. The model will produce source-to-target examples that teach tone preservation, terminology substitution, and format adaptation for a specific locale. This is useful for localization engineers who need to build training data or test cases for machine translation quality assurance, or for developers who want to embed locale-aware behavior into an LLM-powered application without writing hundreds of lines of procedural instructions.

textCopy
You are a localization demonstration generator. Your task is to convert a set of localization rules into a series of example pairs that teach an AI model how to adapt content for the [TARGET_LOCALE] locale.

## INPUTS
- **Localization Rules:** [LOCALIZATION_RULES]
- **Terminology Map:** [TERMINOLOGY_MAP]
- **Source Samples:** [SOURCE_SAMPLES]

## OUTPUT SCHEMA
Generate a JSON array of demonstration objects. Each object must have the following fields:
- `source_text`: A string containing the original text in the source language.
- `target_text`: A string containing the adapted text for the [TARGET_LOCALE] locale.
- `adaptation_notes`: A brief string explaining which rules or terminology were applied.

## CONSTRAINTS
- The `target_text` must strictly adhere to the provided [LOCALIZATION_RULES] and [TERMINOLOGY_MAP].
- Preserve the original tone and intent unless a rule explicitly requires a change.
- Adapt formatting (dates, numbers, currencies) to the conventions of [TARGET_LOCALE].
- If a source sample cannot be adapted because it violates a core rule, generate a negative example showing the incorrect adaptation and explain why it is wrong in the `adaptation_notes`.
- Output ONLY the JSON array. Do not include any other text.

## EXAMPLES
[EXAMPLES]

## RISK LEVEL
[RISK_LEVEL]

To adapt this template, replace the square-bracket placeholders with your specific assets. [LOCALIZATION_RULES] should contain the natural-language instructions from your style guide (e.g., 'Use a formal tone for all business communications'). [TERMINOLOGY_MAP] is a key-value mapping of source terms to approved target terms (e.g., {"car": "voiture", "truck": "camion"}). [SOURCE_SAMPLES] are the original strings you want to create demonstrations for. The [EXAMPLES] placeholder is critical for few-shot learning; provide 2-3 high-quality demonstration objects that match the output schema exactly. Set [RISK_LEVEL] to high if the output will be used in a customer-facing production system, which should trigger a human review step before deployment. For high-risk workflows, always validate the generated JSON against the schema and spot-check the adaptation_notes for accuracy.

This prompt is designed to sit between a localization management system and a content delivery pipeline. The typical integration pattern involves fetching a source string and its associated locale rules from a translation memory or style guide database, assembling the prompt with the [SOURCE_TEXT], [SOURCE_LOCALE], [TARGET_LOCALE], and [LOCALE_RULES] placeholders, and then sending the request to the model. The output is a structured adaptation example that can be stored as a reference pair for translators, used to fine-tune smaller models, or fed directly into a review queue. The harness must treat this prompt as a generation step, not a final publish step—every output requires validation before it reaches a human translator or an automated translation system.

Wire the prompt into your application with a validate-then-review pattern. After receiving the model response, run three checks before allowing the output to proceed: (1) Schema validation—confirm the output contains the expected source_text, target_text, adaptation_notes, and terminology_substitutions fields with correct types. (2) Locale consistency—verify that the target_locale in the output matches the requested [TARGET_LOCALE] and that any locale-specific formatting (dates, numbers, currencies) follows the target locale conventions. (3) Terminology accuracy—cross-reference the terminology_substitutions array against your approved termbase for the target locale; flag any substitutions that introduce unapproved terms. If any check fails, route the output to a repair prompt with the validation error details, or escalate to a human reviewer if the failure persists after one retry. Log every validation result, the model used, the prompt version, and the retry count for auditability.

For high-volume pipelines, batch requests by locale pair to maximize prompt cache hits. If you are using a model that supports prompt caching (such as Claude with cache control or OpenAI with automatic caching on repeated prefixes), place the [LOCALE_RULES] and static instruction text at the beginning of the prompt and keep the [SOURCE_TEXT] at the end. This allows the system instructions and locale rules to be cached across hundreds of source strings for the same locale pair, reducing latency and cost. When integrating with a translation management system (TMS), store the generated adaptation examples as translation memory entries with a source=ai-generated flag so human translators can distinguish them from human-created reference pairs. Never publish AI-generated adaptations directly to production content without a human-in-the-loop review step, especially for regulated industries, legal content, or customer-facing UI strings where a terminology error could cause compliance or trust issues.