Hate Speech and Harassment Classification Prompt

This prompt is designed for trust and safety engineers, content moderation teams, and API platform operators who need to classify user-generated text against a defined hate speech and harassment taxonomy. It is built for the ingress layer of an AI system, before content is stored, displayed, or passed to downstream models. Use this prompt when you need structured, auditable classification output that includes severity levels, protected characteristic targeting, and contextual factors. This is not a general-purpose toxicity scorer. It is a classification and triage tool that produces a decision record suitable for human review queues, automated actioning, and audit logging. The prompt assumes you have a defined policy taxonomy and that ambiguous cases will be escalated, not auto-resolved.

Deploy this prompt when your platform requires consistent, policy-aligned decisions about hate speech and harassment. It is appropriate for social media feeds, community forums, gaming chat, API platforms accepting third-party content, and any system where user-generated text must be screened before publication or model ingestion. The prompt expects a pre-defined taxonomy of violation categories, protected characteristics, and severity tiers. You must supply these as part of the [POLICY_TAXONOMY] placeholder. The output is designed to be consumed by a rules engine or review queue dispatcher, not displayed directly to end users. Do not use this prompt for real-time chat filtering where latency must be under 200ms without streaming, for platforms without a defined hate speech policy, or for jurisdictions where legal definitions of hate speech differ materially from your supplied taxonomy without legal review.

Before integrating this prompt, ensure you have established your escalation criteria and human review capacity. The prompt will flag ambiguous cases, coded language, and context-dependent harassment, but it cannot replace human judgment for edge cases. You should pair this prompt with a separate Abuse Escalation and Human Review Routing Prompt to handle the ESCALATE decisions this classifier produces. Always log the full classification payload, including confidence scores and evidence excerpts, for audit and model evaluation purposes. Never use the output of this prompt to automatically ban users without a human review path for high-severity classifications.

This template provides a complete, copy-ready prompt for classifying user-generated content for hate speech and harassment. It is designed to be dropped into a moderation pipeline, an API gateway, or a human-review queue. The prompt enforces a strict JSON-only output contract, a defined severity taxonomy, and explicit rules for handling contextual factors like reclaimed language, counter-speech, and coded terms. Before using this prompt, you must define your organization's specific protected characteristic categories, severity tiers, and escalation thresholds in the [TAXONOMY] and [ESCALATION_RULES] placeholders.

textCopy
System: You are a content moderation classifier. Your only job is to analyze the provided text and return a valid JSON object that strictly follows the output schema. Do not include any text, explanation, or commentary outside the JSON object. Apply the taxonomy and rules defined below without deviation. If the text is ambiguous, err on the side of flagging for human review rather than dismissing.

## TAXONOMY
[TAXONOMY]

## ESCALATION RULES
[ESCALATION_RULES]

## CONTEXTUAL RULES
- Distinguish between hate speech targeting a protected group and counter-speech, educational discussion, or self-referential reclaimed language.
- Coded language, dog whistles, and in-group terminology should be classified based on their known harmful meaning, not their literal text.
- Sarcasm and humor do not excuse hate speech if the underlying message targets a protected characteristic.
- If the text contains a direct threat of violence, the severity must be set to 'critical' regardless of other factors.

## OUTPUT SCHEMA
Return only a single JSON object with the following structure:
{
  "classification": {
    "is_hate_speech": boolean,
    "is_harassment": boolean,
    "severity": "none" | "low" | "medium" | "high" | "critical",
    "primary_category": string,
    "secondary_categories": [string],
    "targeted_characteristics": [string]
  },
  "evidence": {
    "triggering_spans": [string],
    "rationale": string
  },
  "routing": {
    "recommended_action": "allow" | "flag" | "quarantine" | "block" | "escalate",
    "requires_human_review": boolean,
    "review_priority": "low" | "medium" | "high" | "urgent"
  },
  "confidence": number
}

User: [INPUT]

Adapting the template: Replace [TAXONOMY] with your organization's specific hate speech categories, protected characteristics, and definitions. Replace [ESCALATION_RULES] with concrete thresholds that map severity and confidence scores to routing actions. The [INPUT] placeholder should be populated with the raw user-generated text at runtime. For high-stakes production use, pair this prompt with a validation layer that checks the JSON schema before the output reaches any downstream system. If the model fails to return valid JSON, implement a retry with a stronger format constraint or escalate directly to a human queue. Always log the raw input, the full model response, and the final routing decision for auditability.

This prompt is designed to sit at the ingress layer of a content moderation pipeline, receiving user-generated text and returning a structured classification payload. The harness must treat the model output as a signal, not a final decision. Every classification should be logged with the raw input, model response, confidence scores, and any override actions for auditability. Because hate speech detection carries high stakes—false negatives allow harm through, false positives silence legitimate speech—the implementation must include a mandatory human review path for mid-confidence and high-severity outputs.

Wire the prompt into an asynchronous processing queue rather than blocking the user request. When content is submitted, enqueue a moderation task that calls the LLM with the prompt template, passing [INPUT_TEXT] as the user content and [POLICY_TAXONOMY] as the hate speech categories your platform enforces. Parse the JSON response and validate it against a strict schema: require classification (enum of allowed labels), severity (integer 1-5), protected_characteristics (array of strings), confidence (float 0-1), and evidence_excerpts (array of strings with character offsets). Reject malformed responses and retry once with a repair prompt that includes the validation error. If the retry also fails, escalate to a human moderator with the raw input and both failed attempts attached.

For routing decisions, implement a threshold matrix. High-confidence (≥0.9) low-severity (1-2) classifications can auto-resolve with actions like hiding content or flagging for review. High-confidence high-severity (4-5) classifications should trigger immediate content removal and queue for human confirmation within your SLA window. Mid-confidence (0.6-0.89) outputs across any severity must route to the human review queue with the model's classification as a suggested label. Low-confidence (<0.6) outputs should be treated as ambiguous and routed for human decision without model suggestion to avoid anchoring bias. Log every routing decision with the model, prompt version, confidence, and final disposition for downstream eval and model improvement.

Model choice matters here. Use a model with strong instruction-following and low refusal rates on sensitive topics—classifiers that refuse to analyze hate speech are useless. Test against a golden dataset of known hate speech, edge cases (reclaimed slurs, counter-speech, academic discussion), and adversarial examples (coded language, dog whistles, obfuscated terms) before deployment. Run regular eval passes comparing model classifications against human moderator decisions to detect drift in sensitivity or emerging evasion patterns. Store all decisions in a structured format that supports recall, precision, and fairness audits across protected characteristic categories.