Reference

Prompt & Human+AI Interaction — Pattern Cheat Sheet

A practical, example-rich cheat sheet of prompt patterns and human-in-the-loop flows you can reuse. Includes templates, verification points, common failure modes, and quick adoption guidance to make prompts more reliable and auditable in hybrid workflows.

Prompt & Human+AI Interaction — Pattern Cheat Sheet

Practical, reusable patterns for designing prompts and human+AI flows that produce reliable, verifiable outputs. Each pattern shows when to use it, a template with placeholders you can copy, signals you can check to verify the result, common failure modes, and quick fixes.

How to use this cheat sheet

Start by picking the pattern that matches your goal (summarize, answer with sources, break down instructions, have the model check before acting, or require human verification). Replace placeholders in the template, run a small test, and add the verification checks listed for that pattern into your workflow or automated tests.

Pattern: Data summarization (concise, faithful overview)

When to use: Turn long documents, meeting notes, logs, or transcripts into short, accurate summaries for humans or downstream processes.

Template
Role: You are a concise summarizer.
Input: {{DOCUMENT_TEXT}}
Task: Produce a summary of up to {{MAX_TOKENS}} words that captures the main findings, action items (if any), and any open questions. Label each section: Findings, Action Items, Open Questions.
Style: Use bullets for action items and one-line bullets for findings.
Verification signals
  • Does the summary mention the named entities present in the document? (spot-check)
  • Do action items include explicit owners or next steps when present in the source?
  • Is the summary length within the requested bound?
Common failures & fixes
  • Hallucinated facts — reduce abstraction: ask for explicit source quotes or attach excerpt IDs.
  • Missing action items — increase instruction specificity: "List any sentences containing verbs of commitment as Action Items."

Pattern: Question-answering with sources (verifiable answers)

When to use: Provide an answer and cite exact source passages or document identifiers so a human can verify the claim.

Template
Role: You are an evidence-first assistant.
Context: The following documents are available: {{DOC_IDs_AND_SHORT_DESCRIPTIONS}}.
Question: {{USER_QUESTION}}
Task: Answer the question in one paragraph. After the answer, list up to 3 supporting source citations in the format [DocumentID: paragraph/snippet number] and include short quoted excerpts (<= 40 words) that directly support the answer.
If you cannot find support in the provided documents, respond: "No supported answer found in provided documents." Do not invent sources.
Verification signals
  • Each claim has a citation in the requested format.
  • Quoted excerpts match text in the referenced documents (automated string match when possible).
  • If answer is "No supported answer found," log for human review instead of returning a fallback guess.
Common failures & fixes
  • Fabricated citations — implement an automated post-check that verifies citations against an index of provided texts.
  • Overly long answers — enforce a maximum token/word length in the system instruction.

Pattern: Instruction decomposition (reliable multi-step plans)

When to use: Convert a high-level task into sequenced, testable subtasks that can be assigned or automated.

Template
Role: You are a task decomposition assistant.
Input: {{HIGH_LEVEL_TASK}}
Task: Break the task into ordered steps. For each step provide: Description, Inputs required, Expected output, Estimated duration, and Risk notes. Mark any step that requires human approval with "[Human Approval Required]".
Return: A numbered list of steps suitable for execution or handoff.
Verification signals
  • Every step has both inputs and outputs defined.
  • No step is longer than one actionable sentence (to keep tasks small).
  • Steps flagged for human approval align with high-risk or ambiguous points.
Common failures & fixes
  • Overly granular or too vague steps — calibrate expected duration and level-of-detail in the template.

Pattern: Check-then-act flow (safety & correctness)

When to use: Let the AI propose an action but require an internal check or assertion before performing it (especially when actions are irreversible or costly).

Template
Role: You propose an action and then validate it before execution.
Context: {{SITUATION}}
Step 1 — Propose: Provide a single recommended action and the reasons.
Step 2 — Check: List 3 explicit checks that confirm the action is safe and appropriate, each referencing evidence or rules.
Step 3 — Act: If and only if all checks pass, output: "APPROVED: [action]". Otherwise output: "REJECTED: [reason]".
Verification signals
  • All checks must map to an explicit source, rule, or metric (automated where possible).
  • Action is not executed (or sent downstream) until message equals an "APPROVED" token observed by the orchestration layer.
Common failures & fixes
  • Checks that are vague or untestable — require checks to be boolean or numeric checks (e.g., "price_delta <= 5%" rather than "looks OK").

Pattern: Human review triggers (where human judgment is required)

When to use: Escalate to a human when the model is uncertain, when the action is high-impact, or when regulatory/auditability requirements exist.

Template
Role: You should flag outputs for human review under specified conditions.
Context: {{PROCESS_OR_OUTPUT}}
If any of the following conditions are true: {{LIST_OF_TRIGGERS}}, then output a "Human Review Required" record containing: human_readable_summary, why_flagged (one short sentence), risk_level (low/medium/high), suggested reviewer role.
Verification signals
  • Flags are accompanied by structured metadata so reviewers can triage quickly.
  • Review outcomes are recorded back into the system (accepted/rejected/changed) for future model calibration.
Common failures & fixes
  • Too many false positives — refine triggers with thresholding or add a secondary lighter-weight auto-check before flagging.

Practical guardrails & prompt engineering notes

  • Use explicit roles: begin with a short system-style line such as "You are an evidence-first assistant" or "You are a conservative safety assistant".
  • Prefer instructions that constrain behavior (format, length, verification) over vague statements like "be helpful."
  • When accuracy matters, require citations or direct text quotes and add an automated citation verifier in your pipeline.
  • Avoid mixing too many goals in one prompt. If you need multiple behaviors, chain prompts (decompose, then solve, then verify).
  • Record examples and failure cases. Use them for prompt tuning and as checks in the pipeline.

Quick adoption checklist

  1. Choose the single pattern that matches your outcome.
  2. Replace placeholders and run a short experiment with a small, representative dataset.
  3. Implement the verification signals as automated checks where possible.
  4. Define human review triggers and a simple logging/feedback loop for reviewers.
  5. Iterate: collect failures, refine prompt templates, and re-run tests.

Next steps and resources

Consider adding a small "prompt test harness" for each pattern: a reproducible input set, expected outputs, and automated checks. Over time, collect human reviewer decisions to close the loop and reduce unnecessary reviews.

Note: This cheat sheet provides patterns and templates for design and testing. Do not rely on prompts alone for regulatory compliance or high-risk decisions—use monitoring, human oversight, and formal validation.

Discuss Ask the Librarian

Discussion

Comments and conversation will live here.