# Bulletproof Skill

> Harden skills against rationalization and bypass behaviors

- Skill: `majiayu000/bulletproof-skill` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/bulletproof-skill`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/bulletproof-skill/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/bulletproof-skill

---


# Bulletproof Skill Command

<identification>
triggers: bulletproof, harden skill, rationalization, loopholes, bypass, red flags

use_when:
- Hardening skills against rationalization and bypass behaviors
- Identifying loopholes in skill language
- Generating rationalization tables
- Creating red flags lists
- Preparing skills for production

do_not_use_when:
- Testing skill functionality - use /test-skill instead
- Evaluating skill quality - use /skills-eval instead
- Creating new skills - use /create-skill instead
</identification>

Systematically hardens skills against rationalization and bypass behaviors.

## Usage

```bash
# Analyze skill for loopholes and rationalizations
/bulletproof-skill skills/my-skill

# Generate full bulletproofing report
/bulletproof-skill skills/my-skill --report

# Apply suggested fixes automatically (interactive)
/bulletproof-skill skills/my-skill --interactive

# Check specific aspects only
/bulletproof-skill skills/my-skill --check loopholes
/bulletproof-skill skills/my-skill --check rationalizations
/bulletproof-skill skills/my-skill --check red-flags
```

## What is Bulletproofing?

**Problem**: LLMs rationalize around constraints through:
- Vague language interpretation ("usually", "try to", "generally")
- "Spirit vs letter" compliance
- Perceived simplicity exemptions
- Memory-based shortcuts

**Solution**: Makes implicit requirements explicit, adds rationalization counters, closes loopholes.

## Workflow

### Step 1: Loophole Analysis
Scans skill content for weakness patterns:
- **Vague Language**: "usually", "try to", "generally", "should"
- **Missing Exceptions**: Undefined terms like "complex", "important"
- **Ambiguous Conditions**: Subjective criteria allowing bypass
- **Escape Hatches**: "Skip if not needed" without criteria

### Step 2: Rationalization Detection
Identifies common bypass patterns:
- Simplicity Bypass: "This is just a simple task"
- Memory Shortcut: "I remember what the skill says"
- Overkill Excuse: "The skill is overkill for this"
- Deferral: "Let me do this one thing first"
- Spirit vs Letter: "Technically following the approach"

### Step 3: Generate Rationalization Table
Creates comprehensive mapping of rationalizations → counters.

### Step 4: Create Red Flags List
Builds self-check questions to catch bypass attempts.

### Step 5: Suggest Counters
Provides explicit anti-rationalization language.

## Severity Levels

- **Critical**: Allows complete skill bypass (MUST fix)
- **High**: Enables significant deviation (SHOULD fix)
- **Medium**: Potential for selective application (CONSIDER fixing)
- **Low**: Minor wording improvements (OPTIONAL)

## Output

### Summary Report
```
LOOPHOLE ANALYSIS
Skill: skills/my-skill v0.2.0

VAGUE LANGUAGE (4 instances)
- Line 23: "Usually follow..." → "ALWAYS follow..."
- Line 47: "Try to establish..." → "MUST establish..."

Total Issues: 10 (Critical: 2, High: 5, Medium: 1, Low: 1)
Recommendation: Address all CRITICAL and HIGH before production
```

### Rationalization Table
```
| Thought | Reality | Counter |
|---------|---------|---------|
| "This is just simple" | Skills prevent scope creep | Apply EVERY time |
| "I remember the skill" | Memory drifts | Read CURRENT version |
```

### Red Flags List
```
## Red Flags - STOP and Check Skill
- "This is just a simple..."
- "I remember what it says..."
- "This doesn't need the full..."
```

## Detailed Guides

For comprehensive patterns and examples, see the bulletproof-skill source code and the abstract methodology framework.

## Best Practices

**When to Bulletproof**:
- Before skill goes to production
- After discovering bypass instances
- When skill compliance is critical
- During skill refactoring

**What Makes Good Bulletproofing**:
- Specific, measurable counters
- Complete rationalization coverage
- Clear red flags
- Actionable fixes

**Common Mistakes**:
- Over-bulletproofing simple skills
- Missing common rationalizations
- Vague counters that invite new rationalizations
- Not testing bulletproofed version

## Integration

```bash
# Typical workflow
/create-skill my-skill          # Create skill
/test-skill my-skill            # Test functionality
/bulletproof-skill my-skill     # Harden against bypass
/skills-eval my-skill           # Final validation
```

## See Also

- **/create-skill**: Create new skills
- **/test-skill**: Test skill functionality
- **/skills-eval**: Evaluate skill quality
- **abstract:methodology-curator**: Browse anti-rationalization frameworks