Graduated Warning Escalation Prompt Template

This prompt is designed for community platforms, social networks, and content moderation systems that need to implement progressive enforcement. Instead of a binary allow/block decision, this prompt generates tiered responses that escalate from an informal reminder to a formal warning and finally to a temporary restriction. Each tier explains the specific behavior that triggered the warning, cites the relevant policy, and states the consequences of continued violation. Use this prompt when your platform needs to track user warning state across sessions, apply consistent escalation logic, and produce user-facing messages that are firm but not punitive on first contact.

This prompt is not a replacement for a full content moderation pipeline. It assumes an upstream classifier or rule engine has already identified a policy violation and assigned a severity level. The prompt's job is to generate the correct user-facing message for the current escalation tier based on the user's violation history. You must provide the user's current warning tier, the specific policy violated, and the evidence of the violation. The prompt will not decide whether a violation occurred or what tier the user should be on—those decisions belong to your application logic. The output is a structured message payload ready for rendering in your notification system, email, or in-app messaging surface.

Do not use this prompt for real-time chat moderation where latency is critical and a simple block message suffices. Do not use it for legal or financial compliance notices that require exact regulatory language reviewed by counsel. Do not use it when the violation is severe enough to warrant immediate permanent suspension—this prompt handles graduated escalation, not zero-tolerance enforcement. If your platform lacks a user warning state store or you cannot reliably track violation history across sessions, implement that infrastructure first. The prompt's escalation logic depends on accurate tier input; feeding it incorrect tier data will produce messages that are either too lenient or disproportionately harsh, undermining user trust and policy credibility.

This prompt template is the core instruction set for a graduated warning escalation system. It is designed to be populated with data from your moderation pipeline and user state store before being sent to the model. The template uses square-bracket placeholders for all dynamic inputs, ensuring a clean separation between the static enforcement logic and the variable data of each specific incident. The goal is to produce a consistent, policy-grounded response that reflects the user's history without requiring the model to track state across sessions.

codeCopy
SYSTEM:
You are a content moderation assistant for [PLATFORM_NAME]. Your task is to generate a user-facing enforcement message based on a specific policy violation and the user's current warning state. You must strictly adhere to the defined escalation tiers and never deviate from the prescribed tone and structure for each tier.

USER:
Generate an enforcement response using the following data:

[USER_WARNING_STATE]
Current Warning Tier: [CURRENT_TIER] (Possible values: NONE, INFORMAL_REMINDER, FORMAL_WARNING, TEMPORARY_RESTRICTION)
Previous Violation Count: [VIOLATION_COUNT]
Date of Last Violation: [LAST_VIOLATION_DATE]

[VIOLATION_DETAILS]
Violating Content: "[VIOLATING_CONTENT_EXCERPT]"
Violated Policy Name: [POLICY_NAME]
Violated Policy Clause: "[POLICY_CLAUSE_TEXT]"
Violation Severity: [SEVERITY] (Possible values: LOW, MEDIUM, HIGH, CRITICAL)

[ESCALATION_RULES]
- If CURRENT_TIER is NONE and SEVERITY is LOW or MEDIUM, the new tier is INFORMAL_REMINDER.
- If CURRENT_TIER is NONE and SEVERITY is HIGH or CRITICAL, the new tier is FORMAL_WARNING.
- If CURRENT_TIER is INFORMAL_REMINDER, the new tier is FORMAL_WARNING.
- If CURRENT_TIER is FORMAL_WARNING, the new tier is TEMPORARY_RESTRICTION.
- If CURRENT_TIER is TEMPORARY_RESTRICTION, the new tier remains TEMPORARY_RESTRICTION.

[RESPONSE_TEMPLATES]
For INFORMAL_REMINDER:
"Hi [USERNAME], we noticed [VIOLATING_CONTENT_EXCERPT] and wanted to send a quick reminder about our [POLICY_NAME] policy: '[POLICY_CLAUSE_TEXT]'. This is just a heads-up, and no action has been taken on your account. Please review our community guidelines. Thanks for being part of [PLATFORM_NAME]."

For FORMAL_WARNING:
"Hi [USERNAME], your recent content '[VIOLATING_CONTENT_EXCERPT]' violates our [POLICY_NAME] policy: '[POLICY_CLAUSE_TEXT]'. This is a formal warning. Further violations may lead to temporary account restrictions. You can review our full policy here: [POLICY_URL]."

For TEMPORARY_RESTRICTION:
"Hi [USERNAME], due to repeated violations, including '[VIOLATING_CONTENT_EXCERPT]' which violates our [POLICY_NAME] policy, your account has been temporarily restricted from [RESTRICTED_ACTIONS] for [RESTRICTION_DURATION]. If you believe this is an error, you can appeal here: [APPEAL_URL]."

[OUTPUT_SCHEMA]
You must output a single JSON object with the following keys:
- "new_tier": The calculated new warning tier for the user.
- "message": The fully populated user-facing message string.
- "internal_note": A brief, non-user-facing note for moderators explaining the escalation decision.

To adapt this template, replace each bracketed placeholder with data from your application's state store and moderation pipeline. The [ESCALATION_RULES] and [RESPONSE_TEMPLATES] sections are defined inline for clarity but can be moved to a separate, cacheable system prompt prefix in production to reduce per-request token usage. The [OUTPUT_SCHEMA] enforces a structured JSON response, which is critical for the implementation harness to parse the new tier and update the user's state. Before deploying, test this prompt against a golden dataset of violations and user states to ensure the escalation logic is followed exactly and that the response templates are populated without hallucination.

The graduated warning prompt template is not a standalone artifact; it is a decision and generation step inside a larger moderation pipeline. The application layer is responsible for maintaining user warning state across sessions, injecting the correct [WARNING_TIER] and [PRIOR_VIOLATIONS] context into each prompt call, and acting on the escalation decisions the model returns. The prompt itself produces a structured output—typically a JSON object containing the warning message, the new tier, and any recommended enforcement action—but the application must validate that output before surfacing it to the user or updating internal state. This separation ensures the model handles natural-language reasoning while the application enforces deterministic rules such as maximum escalation caps, cooldown periods, and mandatory human review thresholds.

To wire this into production, implement a stateful moderation service that queries a user violation store before each prompt call. The service should inject the user's current warning tier (0 through N), a timestamped list of prior violations with policy references, and the current violation context into the prompt's [PRIOR_VIOLATIONS] and [WARNING_TIER] placeholders. After receiving the model response, validate the output against a strict schema: the new_tier field must be an integer within the configured escalation range, the action field must be one of the allowed enforcement actions (none, warn, restrict, suspend, escalate_to_human), and the message field must be non-empty and under the platform's character limit. If validation fails, retry with a repair prompt or fall back to a deterministic template for that tier. Log every prompt call with the input state, raw model output, validation result, and final action taken for audit and regression testing.

The highest-risk failure mode in this pipeline is state drift: the application believes a user is at tier 2 but the model generates a tier 1 warning because of stale or missing context injection. Mitigate this by making the application the authoritative source of truth for warning tier and only allowing the model to recommend escalation, never de-escalation, unless explicitly configured for a cooldown policy. For platforms with legal or safety obligations, route any escalate_to_human recommendation to a review queue immediately and do not allow automated enforcement beyond temporary restrictions without human approval. Before deploying, build a regression test suite that verifies correct tier progression across simulated violation sequences, validates that the model never skips tiers without explicit instruction, and confirms that the audit log captures every state transition with the responsible model version and prompt template hash.