Skip to main content
skill CX Codex

guardrails-safety-filter-builder — Claude Code skill: what it does

guardrails-safety-filter-builder builds a safety layer for an LLM app: masks personal data, catches prompt injection attempts and returns a refusal when a topic is off-policy.

MIT 299 installs ★ 64 updated 2026-01-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a claude-code
Open on GitHub

What guardrails-safety-filter-builder does

The skill wraps an LLM app in a guard layer. It screens the incoming prompt, masks personal data in the reply and sends a canned refusal when a topic falls outside policy. Useful once a bot talks to real users.

Everything ships as Python snippets. PII handling runs on presidio_analyzer and presidio_anonymizer, scanning for EMAIL_ADDRESS, PHONE_NUMBER, CREDIT_CARD and SSN. Injection checks are a short list of regexes, topic control is an allow and deny list plus REFUSAL_TEMPLATES, and output validation looks for banned phrases and a toxicity score. Neither presidio package comes with the snippet, so install both before the redaction example will run.

The apply_guardrails function chains four checks and hands back a dict with the verdict and the response text. Logging blocked requests and testing for bypasses sit in the closing checklist as separate items, so plan to write those yourself.

What it helps with

  • strip emails and card numbers from a model reply before it reaches the user
  • block prompts that try to override the system instruction
  • keep a support bot inside allowed topics with a canned refusal
  • flag banned phrases and toxicity in generated output
  • wire the checks into a single pipeline call

Example prompts for the agent

  • Add guardrails to my support bot so emails and phone numbers get masked in replies
  • Detect prompt injection on user input and return a refusal for legal or medical questions
  • Validate the model output for banned phrases before sending it back

How to install guardrails-safety-filter-builder

1Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a claude-code

2Manually: put the files in place

~/.claude/skills/guardrails-safety-filter-builder/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/guardrails-safety-filter-builder/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about guardrails-safety-filter-builder

How do I install guardrails-safety-filter-builder in Claude Code?

Run npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a claude-code. The skill file lands at ~/.claude/skills/guardrails-safety-filter-builder/SKILL.md.

What does guardrails-safety-filter-builder do?

It builds safety filters for an LLM app: PII masking, prompt injection detection, topic policy, refusal templates and validation of the generated answer.

What do I need for the PII part?

Python plus the presidio-analyzer and presidio-anonymizer packages; the example builds AnalyzerEngine and AnonymizerEngine from them.

Source text

SKILL.md · MIT
---
name: guardrails-safety-filter-builder
description: Implements content safety filters with PII redaction, policy constraints, prompt injection detection, and safe refusal templates. Use when adding "content moderation", "safety filters", "PII protection", or "guardrails".
---

# Guardrails & Safety Filter Builder

Build comprehensive safety systems for LLM applications.

## Safety Layers

1. **Input filtering**: Block malicious prompts
2. **Output filtering**: Redact sensitive data
3. **Topic constraints**: Policy-based refusals
4. **PII detection**: Mask personal information
5. **Prompt injection**: Detect manipulation attempts

## PII Detection & Redaction

```python
import re
from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine

analyzer = AnalyzerEngine()
anonymizer = AnonymizerEngine()

def redact_pii(text: str) -> str:
    # Detect PII
    results = analyzer.analyze(
        text=text,
        language='en',
        entities=["EMAIL_ADDRESS", "PHONE_NUMBER", "CREDIT_CARD", "SSN"]
    )

    # Anonymize
    anonymized = anonymizer.anonymize(text, results)
    return anonymized.text

# Example: "My email is [email protected]" → "My email is <EMAIL_ADDRESS>"
```

## Prompt Injection Detection

```python
def detect_prompt_injection(user_input: str) -> bool:
    """Detect common prompt injection patterns"""
    patterns = [
        r'ignore (previous|above) instructions',
        r'disregard (all|any) (prior|previous)',
        r'you are now',
        r'new instructions',
        r'system:',
        r'override',
    ]

    for pattern in patterns:
        if re.search(pattern, user_input, re.IGNORECASE):
            return True

    return False

# Block if detected
if detect_prompt_injection(user_input):
    return "I cannot process that request."
```

## Topic Constraints

```python
# Define allowed/disallowed topics
POLICY = {
    "allowed_topics": [
        "product_features",
        "troubleshooting",
        "billing",
        "account_management"
    ],
    "disallowed_topics": [
        "medical_advice",
        "legal_advice",
        "financial_advice",
        "politics",
        "violence"
    ],
    "requires_disclaimer": [
        "security_practices",
        "data_privacy"
    ]
}

# Classify topic
def classify_topic(query: str) -> str:
    classification_prompt = f"""
    Classify this query into one of these topics:
    {', '.join(POLICY['allowed_topics'] + POLICY['disallowed_topics'])}

    Query: {query}

    Return only the topic name.
    """
    return llm(classification_prompt)

# Check policy
def check_policy(query: str) -> dict:
    topic = classify_topic(query)

    if topic in POLICY["disallowed_topics"]:
        return {
            "allowed": False,
            "reason": f"Cannot provide {topic}",
            "refusal": REFUSAL_TEMPLATES[topic]
        }

    return {"allowed": True, "topic": topic}
```

## Refusal Templates

```python
REFUSAL_TEMPLATES = {
    "medical_advice": """
        I cannot provide medical advice. Please consult with a healthcare
        professional for medical concerns.
    """,
    "legal_advice": """
        I cannot provide legal advice. For legal matters, please consult
        with a qualified attorney.
    """,
    "out_of_scope": """
        I'm designed to help with product documentation and support.
        This question is outside my area of expertise.
    """,
}

def refuse_safely(reason: str) -> str:
    return REFUSAL_TEMPLATES.get(reason, REFUSAL_TEMPLATES["out_of_scope"])
```

## Output Validation

```python
def validate_output(output: str) -> dict:
    """Check output before returning to user"""
    issues = []

    # Check for PII
    pii_results = analyzer.analyze(output, language='en')
    if pii_results:
        issues.append("Contains PII")
        output = redact_pii(output)

    # Check for banned phrases
    banned_phrases = ["password", "api key", "secret"]
    for phrase in banned_phrases:
        if phrase.lower() in output.lower():
            issues.append(f"Contains banned phrase: {phrase}")

    # Check toxicity
    toxicity_score = toxicity_classifier(output)
    if toxicity_score > 0.7:
        issues.append("High toxicity detected")

    return {
        "safe": len(issues) == 0,
        "issues": issues,
        "sanitized_output": output
    }
```

## Complete Guardrail Pipeline

```python
def apply_guardrails(user_input: str) -> dict:
    # 1. Input validation
    if detect_prompt_injection(user_input):
        return {
            "allowed": False,
            "response": "Invalid request detected."
        }

    # 2. Policy check
    policy_check = check_policy(user_input)
    if not policy_check["allowed"]:
        return {
            "allowed": False,
            "response": policy_check["refusal"]
        }

    # 3. Generate response
    response = llm(user_input)

    # 4. Output validation
    validation = validate_output(response)
    if not validation["safe"]:
        return {
            "allowed": True,
            "response": validation["sanitized_output"],
            "warnings": validation["issues"]
        }

    return {
        "allowed": True,
        "response": response
    }
```

## Best Practices

- Layer multiple defenses
- Log all blocked requests
- Provide helpful refusals
- Redact, don't reject when possible
- Regular pattern updates
- Human review of edge cases

## Output Checklist

- [ ] PII detection implemented
- [ ] Prompt injection detection
- [ ] Topic classification
- [ ] Policy constraints defined
- [ ] Refusal templates written
- [ ] Output validation
- [ ] Logging/monitoring
- [ ] Test cases for bypasses

© patricio0312rev · MIT · patricio0312rev/skills

Similar skills

All skills for Security →

From the same set148

The whole set →
curl-command-generator curl-command-generator turns Express, Next.js or Fastify route definitions into cURL commands you can paste into a terminal, auth headers and JSON bodies included. CX Codex +1 311installs data-integrity-auditor data-integrity-auditor is a Claude Code skill that finds database integrity problems and suggests fixes. It responds to requests about orphaned rows, broken relationships, and data quality. CX Codex +1 306installs queue-job-processor queue-job-processor sets up background job processing with BullMQ and Redis, covering typed queues, worker concurrency, and retry strategies. CX Codex +1 300installs api-mock-server api-mock-server configures mock API servers for testing and frontend development using MSW, json-server, or custom handlers. CX Codex +1 300installs sql-query-optimizer The sql-query-optimizer skill inspects SQL execution plans, suggests indexes, and rewrites queries. Use it when slow database queries need a concrete diagnosis. CX Codex +1 297installs dependency-vulnerability-triage dependency-vulnerability-triage is a Claude Code skill that turns npm audit and Snyk results into a prioritized patch plan with severity ratings, safe upgrade paths, and breaking-change analysis. CX Codex +1 296installs rfc-generator rfc-generator turns a technical proposal into a structured RFC: problem, solution, alternatives, risks and a rollout plan, instead of a blank page. CX Codex +1 294installs backup-restore-runbook-generator The backup-restore-runbook-generator skill builds database disaster-recovery runbooks with backup scripts, restore steps, and validation checks. Use it when planning recovery procedures. CX Codex +1 294installs

Project sponsors

Companies that keep this analytics open