Review Item Packaging Prompt Template

This prompt is for operations leads and support managers who need to convert raw AI outputs, flagged events, or system-generated alerts into structured review packets for a human review queue. The goal is to give a human reviewer everything they need to make a fast, confident decision without hunting through logs, tickets, or source documents. Use this prompt when an AI system or automation has identified something that requires human judgment and you need to package the context, evidence, decision options, and urgency into a single scannable unit. This prompt does not make the decision. It prepares the decision surface.

The prompt assumes that upstream processes have already determined that human review is required. It is designed for asynchronous review queues where a human will pick up the item within minutes or hours. Do not use this prompt for real-time blocking approval flows where latency is measured in milliseconds. In those cases, a lightweight pre-action summary with a blocking condition is more appropriate. The ideal user is someone configuring a triage pipeline who needs a consistent, machine-readable review packet that can be rendered in a queue UI, sent to a ticketing system, or logged as an audit record.

Before using this prompt, ensure you have defined the required input fields: the triggering event, source evidence, any AI-generated analysis or recommendation, and the decision options available to the reviewer. The prompt template uses square-bracket placeholders like [INPUT], [CONTEXT], and [OUTPUT_SCHEMA] that you must populate from your upstream systems. If your review queue handles regulated domains such as healthcare, finance, or legal compliance, you must include evidence grounding requirements and a human review attestation step in the output schema. Never use this prompt to bypass required human review steps or to create the appearance of human review where none occurred.

This template is designed to be used as a system or task prompt whenever an AI system needs to hand off a work item to a human review queue. It forces the model to produce a structured packet that includes the original item, extracted evidence, source grounding, and a clear decision question. Replace every square-bracket placeholder with your specific data, schemas, and policies before sending the prompt to the model.

textCopy
You are a review-item packaging assistant. Your job is to take an AI-generated work item and format it into a structured review packet for a human reviewer. You must not make the decision yourself. Your output must be complete, scannable, and grounded in evidence.

## INPUT
[INPUT]

## OUTPUT SCHEMA
Return a JSON object with the following structure:
{
  "review_packet": {
    "packet_id": "string",
    "generated_at": "ISO8601 timestamp",
    "decision_required": "string (clear yes/no question the reviewer must answer)",
    "urgency": "string (one of: critical, high, medium, low)",
    "item_summary": "string (one-paragraph summary of what happened and what is being asked)",
    "original_item": {
      "source": "string",
      "content": "object (the full original AI output or work item)"
    },
    "evidence_package": [
      {
        "evidence_id": "string",
        "type": "string (source_document, tool_output, user_input, system_log)",
        "excerpt": "string (relevant quoted excerpt, max 500 words)",
        "source_reference": "string (URI, document ID, or log reference)",
        "relevance": "string (why this evidence matters to the decision)"
      }
    ],
    "options": [
      {
        "option_id": "string",
        "label": "string (short action label)",
        "description": "string (what happens if chosen)",
        "risks": ["string"],
        "evidence_supporting": ["evidence_id"]
      }
    ],
    "missing_information": ["string (list of what is unknown or needed)"],
    "confidence_notes": {
      "overall_confidence": "string (high, medium, low)",
      "key_uncertainties": ["string"]
    },
    "escalation_path": "string (who or what team should review this, if known)"
  }
}

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

## RISK LEVEL
[RISK_LEVEL]

## INSTRUCTIONS
1. Extract the core decision question. If the work item does not contain a clear decision, state what is ambiguous.
2. Attach all relevant evidence. Do not summarize evidence without quoting it. Cite sources.
3. If evidence is missing, list it under missing_information. Do not invent evidence.
4. Present at least two options for the reviewer, even if one is "do nothing."
5. If the risk level is high or critical, flag the item as urgent and require explicit human approval before any action proceeds.
6. Do not execute, approve, or reject the item. Your only job is to package it for human review.

To adapt this template, replace [INPUT] with the raw AI output or work item that needs review. Replace [CONSTRAINTS] with any domain-specific rules, such as regulatory requirements, SLA windows, or organizational policies. Replace [EXAMPLES] with one or two few-shot examples of correctly packaged review packets for your domain. Replace [RISK_LEVEL] with the assessed risk level of the workflow. In high-risk domains such as healthcare, finance, or legal, always route the final packet through a human approval step and log the reviewer's decision for audit purposes. Validate the output JSON against the schema before enqueuing it; if validation fails, retry with a repair prompt or escalate the raw item directly.

The Review Item Packaging Prompt is designed to be called by an application layer just before an item enters a human review queue. The application is responsible for gathering all source evidence, user context, and decision history, then passing it into the prompt as structured inputs. The prompt itself does not fetch data or make routing decisions—it only formats the provided inputs into a reviewer-ready packet. This separation keeps the prompt testable and the application responsible for data integrity.

Implement a wrapper function that constructs the prompt request with the required placeholders: [ITEM_DESCRIPTION], [EVIDENCE_ATTACHMENTS], [SOURCE_CITATIONS], [DECISION_CONTEXT], [URGENCY_CLASSIFICATION], and [OUTPUT_SCHEMA]. After receiving the model response, validate the output against the expected schema before the item enters any queue. A strict JSON schema validator should check for required fields (review_packet_id, summary, evidence_list, citation_map, decision_options, urgency_label, reviewer_instructions), correct types, and non-empty values for critical fields. If validation fails, retry once with the validation errors appended to the prompt as [CONSTRAINTS]. If the second attempt also fails, log the failure and route the raw item to a manual triage queue with a packaging_failed flag.

For high-risk domains such as finance, healthcare, or compliance, insert a human-in-the-loop checkpoint after packaging. The packaged review item should be written to an audit log with a unique review_packet_id, timestamp, model version, and the full prompt and response payload. Before the item appears in a reviewer's queue, a lightweight pre-screen can check for obvious packaging errors (e.g., missing evidence links, empty decision options) and flag the item for a lead reviewer. Use a model with strong JSON mode and low latency for this prompt—GPT-4o or Claude 3.5 Sonnet are good defaults. Avoid using this prompt for real-time chat interfaces where the user expects an immediate answer; it is designed for asynchronous review workflows where a human will act on the packet within minutes or hours, not seconds.

When integrating with existing queue systems like Jira, ServiceNow, or custom ticketing platforms, map the prompt's output fields to the target system's ticket schema. The reviewer_instructions field should become the ticket description, urgency_label should map to priority fields, and evidence_list should be attached as linked resources or inline references. Do not allow the model to set ticket assignment or SLA timers directly—those should be applied by the application layer based on the urgency_label and organizational policy. Finally, instrument the pipeline with observability hooks: log the time from prompt call to validation pass, track the retry rate, and monitor the percentage of items that fail packaging entirely. These metrics will tell you when the prompt or the input data quality needs attention.