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
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/guardrails-safety-filter-builder/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/guardrails-safety-filter-builder/
1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a codex2Manually: put the files in place
.agents/skills/guardrails-safety-filter-builder/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a cursor2Manually: put the files in place
.cursor/skills/guardrails-safety-filter-builder/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install patricio0312rev/skills ai-engineering/guardrails-safety-filter-builder/SKILL.md2Manually: put the files in place
.github/skills/guardrails-safety-filter-builder/SKILL.md1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a gemini-cli2Platform CLI
gemini skills install https://github.com/patricio0312rev/skills --path ai-engineering/guardrails-safety-filter-builderManually: put the files in place
.devin/skills/guardrails-safety-filter-builder/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill guardrails-safety-filter-builder -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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