Example Augmentation with Hallucination Injection for Detection Training Prompt

This prompt is designed for machine learning engineers and AI safety teams who are building or fine-tuning hallucination detection models. Its primary job is to transform a set of factually correct seed examples into a labeled training dataset where each example contains a controlled, documented factual error. You need this when you have a high-quality corpus of ground-truth outputs but lack sufficient negative examples to teach a classifier or judge model to reliably identify fabrications, unsupported claims, and citation errors.

The ideal user has a collection of verified, source-grounded text passages—such as RAG outputs with citations, summarized research findings, or extracted clinical notes—and needs to systematically degrade them. The prompt requires you to specify the type of hallucination to inject (e.g., entity swap, fabricated citation, contradictory claim), a difficulty level for the detection task, and the expected output schema for the augmented example. You should not use this prompt if your seed data already contains unverified claims, as the injection process will compound existing errors and produce a noisy, unreliable training set. It is also unsuitable for generating adversarial content intended to evade production safety filters without a formal red-teaming process and human review.

Before integrating this prompt into a data generation pipeline, ensure you have a validation step that confirms the injected error matches the requested type and difficulty. A common failure mode is generating an error that is either trivially obvious or semantically nonsensical, which teaches the detector to latch onto superficial patterns rather than genuine factual inconsistency. Start by running this prompt on a small, manually reviewed batch of 20–50 seeds to calibrate the [ERROR_TYPE] and [DIFFICULTY] parameters before scaling to thousands of examples. Pair this with the 'Example Validation and Quality Assurance' playbook to automatically filter out low-quality augmentations.

This prompt template is designed to take a factually correct seed example and inject controlled hallucinations—unsupported claims, fabricated citations, entity swaps, and subtle factual distortions—to create labeled training data for hallucination detection models. The template uses square-bracket placeholders for all variable inputs, making it straightforward to integrate into a data generation pipeline. Each generated example includes an error-type label and a difficulty calibration score, which are essential for training classifiers that can distinguish between different categories of hallucination and for building progressive evaluation sets.

textCopy
You are a training data generator for a hallucination detection system. Your task is to take a factually correct seed example and produce a set of augmented examples, each containing a controlled factual error. You must vary the error type, subtlety, and position within the text.

## INPUT
Seed Example: [SEED_TEXT]
Domain Context: [DOMAIN_DESCRIPTION]
Source Grounding: [SOURCE_EVIDENCE]

## OUTPUT SCHEMA
Return a JSON array of augmented examples. Each object must have these fields:
{
  "augmented_text": "string (the modified text with injected hallucination)",
  "error_type": "enum: unsupported_claim | fabricated_citation | entity_swap | numerical_distortion | temporal_error | attribution_error | contradictory_statement | overgeneralization",
  "error_span": "string (exact substring that contains the error)",
  "error_description": "string (explanation of what was changed and why it's wrong)",
  "difficulty_level": "enum: easy | moderate | hard | adversarial",
  "ground_truth_correction": "string (the correct version of the error span)",
  "seed_preservation_score": "float 0.0-1.0 (how much of the original structure and non-error content is preserved)"
}

## CONSTRAINTS
- Generate exactly [NUM_VARIANTS] augmented examples.
- Distribute error types across: [ERROR_TYPE_DISTRIBUTION].
- Distribute difficulty levels across: [DIFFICULTY_DISTRIBUTION].
- For "easy" difficulty: make the error obvious and easily detectable by a fact-checker.
- For "moderate" difficulty: make the error plausible but verifiable against the source evidence.
- For "hard" difficulty: make the error subtle, requiring domain expertise or cross-referencing to detect.
- For "adversarial" difficulty: make the error nearly indistinguishable from a correct statement, such as a slightly wrong date, a subtly altered statistic, or a citation that looks real but doesn't exist.
- Never alter more than [MAX_ERROR_PERCENTAGE]% of the original text.
- Preserve the original text structure, tone, and formatting outside the error span.
- For "fabricated_citation" errors, generate realistic-looking but non-existent citations (authors, titles, journals, DOIs).
- For "entity_swap" errors, replace a named entity with a similar but incorrect one from the same domain.
- Do not introduce errors that are offensive, harmful, or that could propagate misinformation if accidentally released. All errors must be clearly labeled and controllable.
- If the seed example contains [SENSITIVE_ATTRIBUTES], do not alter those spans.

## EXAMPLES
[FEW_SHOT_EXAMPLES]

## OUTPUT FORMAT
Return only the JSON array. No additional text, no markdown fences.

To adapt this template for your pipeline, start by defining your seed examples and source evidence carefully—the quality of the hallucinations depends on having a clear ground truth to deviate from. The [ERROR_TYPE_DISTRIBUTION] and [DIFFICULTY_DISTRIBUTION] placeholders let you control the composition of your training set; for an initial detection model, aim for a balanced mix of error types with a heavier weight on moderate and hard examples. The [FEW_SHOT_EXAMPLES] placeholder is critical: include at least three worked examples showing different error types and difficulty levels to calibrate the model's output quality. After generation, validate each augmented example by checking that the error_span is an exact substring match in the augmented_text, that the ground_truth_correction matches the original seed, and that the seed_preservation_score is above 0.85. For high-stakes detection systems, route a sample of generated examples through human review before adding them to your training set, and log all generation parameters for auditability.

This prompt is designed to run as a batch job, not a real-time user-facing endpoint. The typical integration pattern is a Python script or Airflow DAG that reads a seed dataset of verified factual examples, iterates through each record, calls the LLM with this prompt, validates the structured output, and writes the augmented examples to a training data store. Because the prompt deliberately generates false claims, the output must never flow directly into a production RAG system or customer-facing model without explicit labeling and downstream filtering. The primary consumers are ML engineers building hallucination detection classifiers and factuality evaluators who need controlled negative examples.

Pipeline integration steps: (1) Load seed examples from a trusted source with ground-truth labels. (2) For each seed, construct the prompt with [SEED_EXAMPLE], [ERROR_TYPES], [DIFFICULTY_LEVEL], and [OUTPUT_SCHEMA] populated. (3) Call the model with response_format set to JSON mode if available, or enforce schema via the prompt's output contract. (4) Validate each returned example: confirm the error_type field matches one of the requested types, verify the injected_claim is actually present in the augmented_text, and check that the detection_difficulty field is populated. (5) Run a secondary verification prompt or heuristic to confirm the injected error is genuinely false—this prevents the model from accidentally generating a correct statement and labeling it as a hallucination. (6) Append validated records to the training set with metadata including seed ID, error type, difficulty, and generation timestamp.

Model choice and retries: Use a model with strong instruction-following and structured output capabilities. For high-volume pipelines, consider a faster model for initial generation and a more capable model for spot-check validation. Implement exponential backoff with a maximum of three retries on schema validation failures. If a seed example fails validation after three attempts, log the failure with the seed ID and error details, then skip to the next record. Do not silently drop failures—these often indicate seeds that are too short, too ambiguous, or contain edge cases worth reviewing. Human review gate: For the first batch of 50-100 generated examples, have a domain expert manually review a random sample to confirm that injected errors are plausible but false, that difficulty labels are calibrated, and that no sensitive information from seeds is leaking in unexpected ways. After the initial gate, switch to periodic spot-check sampling rather than full review.

What to avoid: Do not use this prompt on seeds that contain real user data, PII, or confidential information without redaction. Do not store generated examples in the same dataset as verified factual examples without clear labeling—a source: 'hallucination_injected' metadata field is the minimum. Do not assume the model will always inject exactly one error per example; validate the count and discard or repair outputs that inject zero or multiple unlabeled errors. Finally, track the distribution of error types and difficulty levels across your generated set to ensure balanced coverage for downstream classifier training.