Clarification Question Generation Prompt

This prompt is for support and triage system builders who need to resolve ambiguity before routing. When a classifier returns low confidence or an ambiguity detector flags an input, this prompt generates a single, targeted clarification question designed to resolve the specific uncertainty blocking classification. It is not for general conversational disambiguation or multi-turn dialogue management. Use it as the question-generation step inside a clarify-then-route pipeline, where the output feeds directly into a user-facing interface or a follow-up classification attempt.

The ideal user is an AI platform engineer or product developer integrating this prompt into a deterministic routing middleware. The required context includes the original ambiguous user input, the classification attempt that failed or produced low confidence, and the specific ambiguity type (e.g., overlapping intents, missing entities, conflicting signals). The prompt expects you to supply these as [AMBIGUOUS_INPUT], [CLASSIFICATION_CONTEXT], and [AMBIGUITY_DETAILS] placeholders. The output is a single clarification question string, not a dialogue turn or a list of options. This constraint keeps the prompt focused on resolving the blocking uncertainty rather than drifting into open-ended conversation.

Do not use this prompt when the ambiguity is trivial, when the cost of clarification exceeds the cost of a routing error, or when you need a full multi-turn disambiguation dialogue. For those cases, use the Disambiguation Dialogue Prompt Template or the Clarify-vs-Route Decision Prompt Template instead. Before deploying, validate that generated questions are grammatically correct, reference only information present in the input, and do not introduce new assumptions. Set up eval checks that simulate user responses to the clarification question and verify that the follow-up classification succeeds with higher confidence. If the clarification question fails to improve classification confidence in more than 20% of eval cases, review your ambiguity detection thresholds and the prompt's instruction clarity.

This prompt template is designed to be pasted directly into your prompt layer. It instructs the model to analyze an ambiguous user input, identify the specific uncertainty blocking classification, and generate exactly one clarification question that resolves that uncertainty. The template uses square-bracket placeholders for all dynamic components—replace each placeholder with your actual values before use. The output is structured JSON so your application can parse the question, suggested options, and the reasoning behind it.

textCopy
You are a clarification specialist in a [SYSTEM_NAME] triage pipeline. Your job is to resolve ambiguity in user inputs before they reach downstream classifiers, routers, or agents.

## INPUT
User input: [USER_INPUT]
Classification attempt: [CLASSIFICATION_RESULT]
Confidence scores: [CONFIDENCE_SCORES]
Available intent categories: [INTENT_CATEGORIES]
Conversation history (if any): [CONVERSATION_HISTORY]

## TASK
1. Identify the specific ambiguity that is blocking confident classification.
2. Determine what missing piece of information would resolve that ambiguity.
3. Generate exactly ONE clarification question that targets that missing information.
4. Provide 2-4 suggested answer options the user can choose from.
5. Explain which intent categories the answer will distinguish between.

## CONSTRAINTS
- Ask only ONE question. Do not ask multiple questions.
- The question must be answerable with a short response or single selection.
- Do not repeat information the user already provided.
- Do not ask questions that don't affect the classification decision.
- If the input is not actually ambiguous, return "no_clarification_needed" with the best-guess classification.
- Use the user's language and terminology where possible.
- Keep the question under [MAX_QUESTION_LENGTH] characters.

## OUTPUT SCHEMA
Return valid JSON only:
{
  "needs_clarification": boolean,
  "ambiguity_type": "missing_entity" | "conflicting_signals" | "underspecified_intent" | "multiple_possible_intents" | "unknown_term" | "other",
  "blocking_uncertainty": "string describing what specifically is unclear",
  "clarification_question": "string, the single question to ask",
  "suggested_options": ["option1", "option2", ...],
  "intents_being_distinguished": ["intent_a", "intent_b"],
  "fallback_classification_if_unanswered": "string or null",
  "rationale": "string explaining why this question resolves the ambiguity"
}

## EXAMPLES
[FEW_SHOT_EXAMPLES]

## RISK LEVEL
[RISK_LEVEL]

Adaptation guidance: Replace [USER_INPUT] with the raw user message. [CLASSIFICATION_RESULT] should contain the top-k predicted intents and their scores from your upstream classifier. [INTENT_CATEGORIES] is your full taxonomy so the model knows what it's distinguishing between. [FEW_SHOT_EXAMPLES] should include 2-4 examples covering your most common ambiguity patterns—this is critical for output consistency. [RISK_LEVEL] controls the model's conservatism: set to "high" for regulated domains where over-clarification is safer than misrouting, or "standard" for general use. After generating the question, validate the JSON output against the schema before presenting it to the user. If the output fails validation, retry with the error message appended to the prompt.

This prompt is designed to be called as a secondary step within a classification pipeline, not as a standalone chat interface. The primary classifier should first return a low-confidence or ambiguous-intent signal. Only then should this prompt be invoked to generate a single, targeted clarification question. The harness must enforce this gating: if the primary classifier's confidence score exceeds your defined threshold, skip this prompt entirely and proceed with routing. This prevents unnecessary clarification loops for inputs that are already clear.

The implementation should wrap the prompt in a function that accepts the original user input, the top-k classification results with their confidence scores, and any relevant conversation history. The function constructs the prompt by injecting these values into the [USER_INPUT], [CLASSIFICATION_RESULTS], and [CONVERSATION_HISTORY] placeholders. After receiving the model's response, validate the output against a strict schema: it must contain a single question string and a target_ambiguity field that references which specific classification uncertainty the question aims to resolve. If the output fails schema validation, retry once with an error message injected into the prompt context. If it fails again, fall back to a generic clarification like 'Could you provide more detail about your request?' and log the failure for prompt debugging.

For model choice, use a fast, cost-efficient model for this step since it runs on the critical path of user interaction. A model like GPT-4o-mini, Claude Haiku, or a fine-tuned small open-weight model is appropriate. Latency matters more than deep reasoning here. Implement a timeout of 2-3 seconds; if the model does not respond in time, return the generic fallback question immediately rather than blocking the user. Log all clarification questions, the ambiguity they targeted, and whether the user's subsequent response resolved the classification ambiguity. This data becomes your evaluation dataset for measuring whether your clarification questions are actually useful.

Before deploying, build a small evaluation harness that simulates user responses to generated clarification questions. For each test case in your ambiguity dataset, run the prompt, feed a simulated clarifying response back into the primary classifier, and check whether the confidence score improved above threshold. Track the clarification resolution rate: the percentage of cases where one clarification question was sufficient to resolve the ambiguity. If this rate drops below 70%, revisit the prompt's instruction clarity or the primary classifier's confidence calibration. Never deploy clarification prompts without this closed-loop measurement, as bad clarification questions degrade user experience faster than silent misclassification.