This prompt is a pre-classification stage for domain routing pipelines where static few-shot examples degrade under real-world input variability. Use it when you have a library of labeled examples, a defined domain taxonomy, and a downstream classifier whose accuracy depends on example quality. The job-to-be-done is selecting the most relevant examples from your pool for each incoming request before the classification step, so the classifier sees examples that match the input's length, terminology, and ambiguity profile rather than a fixed set that works for some inputs and confuses others.

The ideal user is an AI platform engineer or ML engineer building a multi-tenant or multi-product routing system. You need a labeled example pool with at least 20–30 examples per domain to make selection meaningful, and you need a downstream classifier prompt that accepts a [SELECTED_EXAMPLES] placeholder. Do not use this prompt when you have fewer than 10 examples per domain, when your classifier already performs above your accuracy threshold with a static prompt, or when latency constraints make an extra model call unacceptable. This prompt is also inappropriate as a replacement for the classifier itself—it selects examples, it does not perform classification.

Before implementing, measure your current classifier's accuracy variance across input lengths and domains. If you see a 15%+ accuracy drop on long or ambiguous inputs, dynamic selection is likely worth the added latency. Wire the selection prompt as a separate call before classification, cache selections per input characteristics if throughput matters, and log which examples were selected alongside classification results so you can measure whether selection actually improves downstream accuracy. Avoid using this prompt when your domain taxonomy changes frequently, since the example pool and selection criteria will need constant maintenance.

This prompt template is the core of your dynamic few-shot example selector. It is designed to be inserted into a step that runs before your main domain classifier. The prompt takes a pool of candidate examples and a new input to classify, then returns a ranked list of the most relevant examples with a relevance score. The goal is to maximize the downstream classifier's accuracy by providing it with examples that are semantically and structurally similar to the input at hand, rather than using a static set.

textCopy
You are an expert example selector for a domain classification system. Your task is to analyze the input text and select the most relevant few-shot examples from the provided candidate pool. The selected examples will be used to guide a downstream classifier, so they must maximize the classifier's ability to correctly identify the domain.

# INPUT TO CLASSIFY
[INPUT]

# CANDIDATE EXAMPLE POOL
[CANDIDATE_POOL]

# SELECTION CRITERIA
1. **Semantic Similarity:** Choose examples whose text is semantically closest to the input. Prioritize examples that share key terminology, intent, and subject matter.
2. **Structural Similarity:** Favor examples that mirror the input's format (e.g., question length, presence of code blocks, list structure).
3. **Domain Coverage:** If the input is ambiguous, select examples that represent the most likely candidate domains to help the downstream classifier disambiguate.
4. **Diversity:** Avoid selecting multiple examples that are near-duplicates of each other. Prioritize a diverse set that covers different facets of the relevant domain(s).

# OUTPUT FORMAT
Return a valid JSON object with a single key "selected_examples". The value must be a list of objects, each with the keys "example_id", "relevance_score", and "rationale". The list must be sorted by "relevance_score" in descending order and contain exactly [K] examples.

```json
{
  "selected_examples": [
    {
      "example_id": "<id from candidate pool>",
      "relevance_score": 0.95,
      "rationale": "One-sentence explanation of why this example was chosen."
    },
    ...
  ]
}

CONSTRAINTS

• Do not select more than [K] examples.
• Only use example_ids that exist in the candidate pool.
• If the candidate pool has fewer than [K] examples, return all of them.
• The relevance_score must be a float between 0.0 and 1.0.

To adapt this template, you must populate the three square-bracket placeholders. [INPUT] is the raw text you need to classify. [CANDIDATE_POOL] should be a structured list of all possible examples, each with a unique example_id and the text of the example. [K] is the integer number of examples you want to select, typically between 3 and 8. The output is a clean JSON payload that your application can parse and use to dynamically construct the prompt for your downstream domain classifier. Ensure your application logic validates that the returned example_id values are present in your source of truth before injecting the corresponding full examples into the next step.

This prompt is not a standalone classifier; it is a pre-processing step that dynamically selects the most relevant few-shot examples for a downstream domain classification call. The implementation harness must treat this as a synchronous dependency: the example selector runs first, its output is validated, and the selected examples are injected into the classifier prompt template. This architecture works best when you maintain a curated example bank—a JSON or database store of labeled domain examples with metadata such as domain, sub-domain, difficulty, and edge-case flags. The selector prompt queries this bank (via retrieval or direct inclusion) and returns a ranked list of example IDs or the full example text to inject into the classifier.

Wire the selector as a function select_examples(input_text, example_bank, top_k=5) that: (1) formats the prompt template with the input text and a serialized subset of the example bank (or retrieves the top-N candidates via vector search before prompting); (2) calls the model with response_format set to a strict JSON schema expecting {"selected_examples": [{"id": "string", "reason": "string"}]}; (3) validates that returned IDs exist in the bank and that the count does not exceed top_k; (4) on validation failure, retry once with an explicit error message injected into the prompt; (5) log the selected IDs, input hash, and latency for offline evaluation. For high-throughput systems, cache selections by input embedding cluster to avoid redundant LLM calls on similar inputs. If the downstream classifier uses a different model family, test that the selected examples transfer well—some models benefit from shorter examples, others from contrastive pairs. Always run an offline eval that compares downstream classification accuracy with random example selection versus selector-chosen examples to confirm the selector adds value.

The primary failure mode is the selector overfitting to surface-level lexical similarity rather than semantic domain fit, especially when the example bank is small or skewed. Mitigate this by including negative examples in the bank (examples that look similar but belong to a different domain) and by periodically auditing selection patterns for bias toward certain example authors or formats. If the downstream classifier has a confidence threshold, route low-confidence classifications to human review and log whether the selector's chosen examples were appropriate—this creates a feedback loop for improving the example bank. Do not let the selector silently mask a bad example bank; if selection quality degrades, fall back to a static curated set and alert the pipeline owner.