Inferensys

Prompt

Source Selection Justification Prompt

A practical prompt playbook for generating comparative justifications when a verification system selects one source over others. Produces human-readable reasoning on authority, recency, and relevance, with guards against post-hoc rationalization.
Developer building agentic RAG system, retrieval pipeline diagram on laptop, technical workspace with notes.
PROMPT PLAYBOOK

When to Use This Prompt

A practical guide for verification engineers and pipeline builders on when to deploy the Source Selection Justification Prompt in automated fact-checking workflows.

This prompt is for verification engineers and pipeline builders who need to explain why one source was preferred over alternatives in an automated fact-checking workflow. Use it when your system has already scored or ranked candidate sources and must produce a traceable, human-readable justification for the selection decision. The ideal user is building a production verification pipeline where source selection decisions must be auditable—either for internal quality assurance, compliance reporting, or reviewer handoff packets. The prompt takes structured assessments of credibility, recency, and domain authority as input and produces a comparative justification that can be logged, reviewed, and included in verification reports.

This is not a source scoring prompt itself. It assumes you have already evaluated each candidate source along dimensions like credibility, recency, domain authority, and relevance to the claim. The prompt's job is to synthesize those structured assessments into a clear explanation of why one source was chosen over others. You should wire this prompt into your pipeline after source scoring and before evidence matching or report generation. The output should be stored alongside the verification decision so that downstream reviewers—whether human analysts, compliance auditors, or automated QA systems—can understand the selection logic without replaying the entire scoring process.

Do not use this prompt when you need to perform the initial source scoring, when you lack structured assessments for each candidate, or when the selection decision is trivial (e.g., only one source available). It is also inappropriate for real-time, low-latency applications where a full comparative justification adds unacceptable overhead; in those cases, log the scores and defer justification to an asynchronous post-processing step. For high-risk domains such as healthcare, legal, or financial verification, always route the generated justification through human review before it becomes part of a final report. The justification should never be presented as the sole evidence for a claim—it is metadata about your process, not a substitute for the source content itself.

PRACTICAL GUARDRAILS

Use Case Fit

Where the Source Selection Justification Prompt delivers value and where it introduces risk. Use these cards to decide if this prompt fits your verification workflow.

01

Good Fit: Multi-Source Verification Pipelines

Use when: your system retrieves multiple candidate sources for a claim and must explain why one was preferred. The prompt adds auditability to automated evidence ranking. Guardrail: always provide the full candidate set in [SOURCE_CANDIDATES]—omitting rejected sources prevents the model from producing a genuine comparative justification.

02

Bad Fit: Single-Source or Trivial Selection

Avoid when: only one source is available or the selection is obvious (e.g., picking the only peer-reviewed paper). The prompt generates post-hoc rationalization when there is no real comparative decision to explain. Guardrail: gate invocation behind a candidate count check—skip the prompt when fewer than two sources exist.

03

Required Inputs: Structured Source Profiles

Risk: the model cannot assess authority, recency, or relevance from a URL alone. Vague inputs produce vague justifications. Guardrail: require structured metadata per source—authority tier, publication date, domain match score, methodology transparency flag—before calling this prompt. Incomplete profiles should trigger input validation, not model inference.

04

Operational Risk: Post-Hoc Rationalization

Risk: the model may generate plausible-sounding justifications that do not reflect the actual ranking logic used upstream. This creates an audit gap between the real selection algorithm and the explained reason. Guardrail: pass the upstream ranking scores alongside sources so the model can ground its justification in actual weights rather than inventing reasons.

05

Operational Risk: Missing Counter-Evidence

Risk: the justification may omit why rejected sources were excluded, making the output look like a one-sided endorsement rather than a comparative decision. Guardrail: include a required output field for rejection rationales per candidate source. Test with eval cases where the best source is not obvious to catch omission failures.

06

Domain Sensitivity: Authority Criteria Vary

Risk: a generic authority justification fails in specialized domains. A government report may be authoritative for policy claims but weak for scientific ones. Guardrail: pass domain-specific authority criteria in [DOMAIN_CONTEXT] and test with cross-domain claim sets to ensure the model adapts its reasoning rather than applying flat rules.

PROMPT PLAYBOOK

Copy-Ready Prompt Template

A copy-ready prompt template for generating a human-readable justification explaining why one source was preferred over alternatives in a verification workflow.

This prompt template is designed to be pasted directly into your application's model call. It instructs the model to act as a verification analyst and produce a structured, comparative justification for a source selection decision. The core task is to explain why a specific source was chosen as the primary evidence for a claim over other available sources, based on authority, recency, and relevance. The output is intended for audit trails, reviewer context, or end-user transparency, not for making the selection itself.

text
You are a meticulous verification analyst. Your task is to generate a clear, concise justification for why a specific source was selected as the primary evidence for a claim over other available alternatives.

# INPUTS
- **Claim:** [CLAIM_TEXT]
- **Selected Source:** [SELECTED_SOURCE_CITATION]
- **Alternative Sources Considered:** [ALTERNATIVE_SOURCES_LIST]
- **Domain Context:** [DOMAIN_OR_TOPIC]

# JUSTIFICATION CRITERIA
Base your justification on a comparative analysis of the sources across these dimensions:
1.  **Authority:** Compare the expertise, official mandate, and reputational credibility of each source for the specific domain.
2.  **Recency:** Evaluate the publication dates relative to the claim's time-sensitivity. Explain why the selected source's timeliness is sufficient or superior.
3.  **Relevance & Directness:** Assess how directly each source addresses the specific claim. Prefer sources providing primary evidence over those offering commentary or inference.

# OUTPUT FORMAT
Produce a single paragraph of 3-5 sentences. Do not use bullet points or markdown formatting in the final output. The justification must:
- Start by stating which source was selected.
- Explicitly compare the selected source against the most credible alternative(s) on at least two of the criteria above.
- Conclude with a definitive statement on why the selected source is the most reliable evidence for this specific claim.
- If no alternative sources were provided, justify the selection on its own merits against an implicit standard of high-quality evidence for the domain.

# CONSTRAINTS
- Do not hallucinate any details about the sources that are not provided in the input.
- If the provided information is insufficient to make a clear determination, state that explicitly and explain what information is missing.
- Maintain a neutral, analytical tone.

To adapt this template, replace the square-bracket placeholders with data from your verification pipeline. The [ALTERNATIVE_SOURCES_LIST] should be a formatted list of citations that were retrieved and scored but not selected. For high-stakes domains like healthcare or finance, always route the generated justification for human review before it is published or logged in an official audit trail. A common failure mode is post-hoc rationalization, where the model invents a plausible-sounding reason that doesn't reflect the actual scoring logic. To mitigate this, test the prompt by providing inputs where the 'selected' source is intentionally weaker on one criterion to see if the justification acknowledges the trade-off or ignores it.

IMPLEMENTATION TABLE

Prompt Variables

Each placeholder required by the Source Selection Justification Prompt, its purpose, a concrete example, and actionable validation rules to prevent common integration failures.

PlaceholderPurposeExampleValidation Notes

[CLAIM]

The specific factual assertion being verified

The company's revenue grew 34% year-over-year in Q3 2024.

Check: non-empty string, max 500 chars. Must be a single atomic claim. If multiple claims detected, split before invoking.

[SELECTED_SOURCE]

Metadata for the source chosen as primary evidence

{'title': 'Q3 2024 Earnings Release', 'url': 'https://...', 'date': '2024-10-15', 'author': 'Investor Relations'}

Check: JSON object with required keys (title, url, date). Date must parse to ISO 8601. URL must be valid format. Null author allowed only if explicitly unavailable.

[ALTERNATIVE_SOURCES]

Array of other sources considered but not selected

[{'title': 'MarketWatch Summary', 'url': '...', 'date': '2024-10-16', 'rejection_reason': 'Secondary reporting, no direct data'}]

Check: JSON array, min 1 item. Each item must include rejection_reason field. Empty array triggers validation warning—justification requires comparison.

[DOMAIN]

The subject domain for authority weighting

financial_reporting

Check: must match one of the allowed enum values in the system prompt (e.g., financial_reporting, medical_research, legal_filing, scientific_publication). Unknown domain triggers fallback to general authority rules.

[RECENCY_THRESHOLD_DAYS]

Maximum acceptable age of evidence in days

90

Check: integer, min 1, max 3650. Null allowed if claim is time-insensitive. If claim date is known, validate that selected source date falls within threshold.

[REQUIRED_AUTHORITY_TIERS]

Minimum acceptable source authority levels

['primary_source', 'official_filing']

Check: JSON array of strings. Must match allowed tier enum. Empty array means any tier accepted. If selected source tier is below minimum, justification must explain exception.

[OUTPUT_FORMAT]

Desired structure for the justification output

paragraph_with_bullets

Check: must be one of ['paragraph', 'paragraph_with_bullets', 'structured_json']. If structured_json, validate output against schema. If paragraph, check for minimum 3 comparative reasoning sentences.

PROMPT PLAYBOOK

Implementation Harness Notes

How to wire the Source Selection Justification Prompt into a production verification pipeline with validation, retries, and audit logging.

The Source Selection Justification Prompt is not a standalone artifact; it is a decision node in a larger verification pipeline. In production, this prompt typically fires after a retrieval step has returned multiple candidate sources for a given claim. The application layer must supply the claim text, a ranked list of candidate sources with their metadata (authority scores, recency, relevance), and the output schema. The model's job is to produce a structured justification explaining which source was selected and why others were rejected. This output is then consumed downstream by evidence matching prompts or stored in an audit trail.

To integrate this prompt reliably, wrap it in a harness that validates the output against a strict JSON schema before accepting it. The schema should require fields such as selected_source_id, justification_summary, comparative_reasoning (an array of objects with source_id, rejection_reason, and comparative_factor), and confidence_level. If validation fails, implement a single retry with the validation error message injected into the prompt context. If the retry also fails, log the failure and route the decision to a human review queue with the full candidate set and raw model output attached. This prevents silent acceptance of malformed justifications in high-stakes verification workflows.

Model choice matters here. Use a model with strong reasoning capabilities and strict JSON mode support. Temperature should be set to 0 or near-zero to maximize deterministic, repeatable justifications. Log every invocation with a unique decision_id, the full prompt payload, the raw and validated outputs, and the latency. This audit trail is critical for downstream governance and for debugging post-hoc rationalization failures, where the model invents plausible-sounding but factually incorrect reasons for preferring a source. Pair this prompt with an independent evaluation step that spot-checks whether the cited rejection reasons (e.g., 'source is outdated') are factually true given the source metadata. If the eval detects a mismatch, flag the decision for review and feed the correction back as a counterexample for future prompt refinement.

IMPLEMENTATION TABLE

Expected Output Contract

Fields, types, and validation rules for the Source Selection Justification response. Use this contract to parse, validate, and store the model output before surfacing it to users or downstream systems.

Field or ElementType or FormatRequiredValidation Rule

selected_source_id

string

Must match an ID from the [CANDIDATE_SOURCES] input array. Parse check: non-empty, exact match required.

selected_source_title

string

Must match the title field of the selected source in [CANDIDATE_SOURCES]. Parse check: non-empty, case-sensitive match.

justification_summary

string

Must be 1-3 sentences. Length check: 50-500 characters. Must not contain placeholder text or generic praise.

authority_comparison

object

Must contain 'selected_score' and 'alternatives' array. Schema check: selected_score is integer 1-5. Each alternative must include source_id and score.

recency_comparison

object

Must contain 'selected_date' in ISO 8601 format and 'alternatives' array with source_id and date. Parse check: valid dates, no future dates.

relevance_comparison

object

Must contain 'selected_relevance' string and 'alternatives' array with source_id and relevance. Enum check: relevance values must be 'high', 'medium', or 'low'.

rejected_sources

array

Must list all other source_ids from [CANDIDATE_SOURCES] not selected. Completeness check: count must equal total candidates minus one.

rejection_reasons

object

Must contain a key for each rejected source_id with a 1-2 sentence reason. Schema check: no missing keys, no empty strings, no circular logic.

PRACTICAL GUARDRAILS

Common Failure Modes

What breaks first when a model justifies source selection and how to guard against it.

01

Post-Hoc Rationalization

What to watch: The model selects a source based on superficial keyword match, then invents plausible-sounding authority or recency reasons that don't hold up under inspection. Guardrail: Require the prompt to list rejected alternatives with specific disqualifying evidence before stating the final choice. Test by providing equally-valid sources and checking if the justification invents differences.

02

Missing Counter-Evidence

What to watch: The justification only cites supporting evidence for the chosen source while ignoring known weaknesses, retractions, or conflicts of interest present in the provided metadata. Guardrail: Add an explicit instruction to surface at least one limitation or risk for the selected source. Validate outputs by checking if known metadata flaws appear in the justification.

03

Recency Override Without Domain Context

What to watch: The model defaults to preferring the most recent source even when the claim domain requires authoritative archival sources, such as legal precedents or historical records. Guardrail: Include a domain-specific recency window parameter in the prompt. For domains where authority trumps recency, state that rule explicitly and test with deliberately outdated authoritative sources versus recent low-authority sources.

04

Comparative Drift into Generic Summary

What to watch: Instead of producing a structured comparison explaining why one source was preferred, the model drifts into summarizing each source individually without a comparative decision. Guardrail: Constrain the output schema to require a ranked list with explicit trade-off reasoning. Use a strict format instruction that prohibits standalone source summaries without comparative language.

05

Echo Chamber False Confirmation

What to watch: Multiple sources that all derive from the same original report are treated as independent corroboration, inflating confidence in the selection. Guardrail: Add a provenance check step that traces each candidate source to its origin. Flag sources with shared lineage and require the justification to disclose when apparent agreement is actually a single source repeated.

06

Undefended Default to Highest-Rated Source

What to watch: When a credibility score or authority tier is provided as input, the model mechanically selects the highest-scored source without considering relevance to the specific claim. Guardrail: Require the prompt to separate authority scoring from relevance matching. The justification must explain why the selected source is authoritative for this specific claim, not just authoritative in general.

IMPLEMENTATION TABLE

Evaluation Rubric

Use this rubric to test the Source Selection Justification Prompt before production deployment. Each criterion targets a known failure mode, including post-hoc rationalization, missing counter-evidence, and recency-authority trade-off errors.

CriterionPass StandardFailure SignalTest Method

Comparative Reasoning Completeness

Output explicitly compares the selected source against at least one rejected alternative on authority, recency, and relevance.

Output only praises the selected source without naming or comparing any rejected alternative.

Automated check for presence of rejected source names and comparative language in the justification text.

Post-Hoc Rationalization Detection

The justification references pre-existing source metadata, not fabricated strengths invented after selection.

Output claims a source is authoritative because it 'agrees with the claim' or uses circular reasoning.

Human review of a sample where the selected source is known to be weaker; check for invented credentials.

Counter-Evidence Acknowledgment

If a rejected source contradicts the selected source, the justification explicitly notes this conflict.

Output ignores contradictory evidence from a higher-authority rejected source.

Test with a source set containing a clear contradiction from a reputable outlet; scan output for conflict mention.

Recency-Authority Trade-Off Explanation

When a newer but less authoritative source is selected over an older authoritative one, the trade-off is explained.

Output selects the newer source without addressing the authority gap, or vice versa.

Test with a source pair where one is recent/low-authority and the other is old/high-authority; check for trade-off language.

Domain Relevance Grounding

Justification ties source authority to the specific claim domain, not generic reputation.

Output states a source is authoritative because it is 'well-known' without domain-specific reasoning.

Test with a medical claim and a general news source; verify output mentions medical expertise or lack thereof.

Abstention on Insufficient Evidence

If no source meets minimum authority or recency thresholds, the output recommends abstention instead of forcing a selection.

Output selects the least-bad source and fabricates a justification for its adequacy.

Test with a source set where all sources are below configured thresholds; check for abstention recommendation.

Structured Justification Format Compliance

Output adheres to the defined [OUTPUT_SCHEMA] with all required fields populated and valid.

Output is free-text without required fields like selected_source_id, rejected_sources, or trade_off_summary.

Schema validation check against the expected JSON structure; flag missing or null required fields.

Citation and Provenance Traceability

Justification includes source identifiers and retrieval timestamps that can be traced back to the evidence store.

Output references sources by vague descriptions without IDs or retrieval metadata.

Parse output for source_id and retrieval_timestamp fields; verify they match records in the test evidence store.

ADAPTATION OPTIONS

Adapt This Prompt

How to adapt

Use the base prompt with a single comparison pair and lighter validation. Drop the structured output schema initially and ask for a paragraph justification. Test with 5-10 source pairs where the correct choice is obvious before scaling.

code
Compare [SOURCE_A] and [SOURCE_B] for claim [CLAIM].
Explain which source you would prefer as evidence and why.
Consider authority, recency, and relevance.

Watch for

  • Post-hoc rationalization where the model picks a source then invents reasons
  • Overweighting recency when authority matters more for the claim domain
  • Missing counter-evidence: the model justifies the winner without explaining why the loser was rejected
Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.