Implement AI Safety Guardrails

This skill designs, implements, and evaluates safety systems for large language models and AI systems, covering content filtering, behavioral restrictions, risk assessment, and responsible deployment. It's built on three principles: defense in depth (multiple safety layers - input validation, model-level safety training like RLHF or constitutional AI, output filtering, access control and rate limiting, and monitoring - rather than relying on any single mechanism), fail-safe design (default to blocking questionable content, escalate edge cases to human review, maintain audit trails, and degrade gracefully under load), and continuous monitoring (real-time safety metrics, regular penetration testing, user feedback, and adversarial evaluation).

On the input side, it provides a multi-classifier guardrail (harm, PII, and jailbreak classifiers combined into a single allow/block decision) and a prompt-injection detector that combines suspicious-pattern regex matching ("ignore previous instructions", role-play framing) with delimiter-attack detection into a single risk score. On the output side, it provides a response-safety evaluator (toxicity, factuality, and privacy checks resolving to blocked/requires-review/approved) and a sanitization function that redacts detected emails and phone numbers and replaces harmful-instruction content with a safe refusal. Monitoring guidance covers an anonymized safety-metrics log and a reporting function summarizing blocked-interaction percentage, average input risk, and top block reasons over a time window.

Advanced patterns cover context-aware safety evaluation (weighing user trust and history, application domain, conversation context, and regulatory requirements) and adaptive thresholds that become more permissive as a user's trust score rises, within a fixed 0.1-0.9 bound.

def get_adaptive_threshold(self, user_id, metric):
    profile = self.user_profiles.get(user_id, {'trust_score': 0.5})
    base_threshold = self.base_thresholds[metric]
    
    adjustment = (profile['trust_score'] - 0.5) * 0.2
    return max(0.1, min(0.9, base_threshold + adjustment))

Use this skill when deploying an LLM or AI system that needs input/output safety filtering - classifying harmful or PII-containing input, detecting prompt injection and jailbreak attempts, sanitizing model output, and monitoring safety metrics over time.

It is not a fit as a one-time filter you set and forget - the skill's own principles frame safety as continuous (regular penetration testing, adversarial evaluation, feedback loops) and explicitly warn against static, unmaintained guardrails as new risks emerge.

Inputs are user prompts (for input guardrails) and model responses (for output guardrails), plus classifier models for harm, PII, jailbreak, toxicity, and factuality. Outputs are allow/block decisions with reasons, sanitized response text with PII redacted, an anonymized safety-metrics log, and a periodic safety report summarizing block rates and top reasons.

AI engineers and safety teams deploying LLM-based systems who need concrete, layered guardrail implementations rather than relying on model-level training alone - following five implementation principles (transparency without revealing attack vectors, proportional response to actual risk, an appeals mechanism for contested decisions, guardrails that don't hurt responsiveness, and maintainability as risks evolve) and starting with conservative thresholds before optimizing.