---
name: rationalization-prevention
description: >-
  Universal anti-rationalization patterns for all rigid behavioral skills.
  Invoked automatically alongside any discipline:rigid skill. Contains iron
  laws and red flag tables that catch common evasion patterns.
type: behavioral
trigger-patterns:
  - rigid skill invoked
  - discipline enforcement
  - rule following
discipline: rigid
category: meta
tags:
  - rationalization
  - discipline
  - enforcement
---

# Rationalization Prevention

## The Iron Law

```
IF YOU ARE RATIONALIZING, STOP AND FOLLOW THE SKILL
```

No negotiation. No special cases. No "just this once."

## What Is Rationalization?

Rationalization is the process of constructing plausible reasons for a decision you've already made for other reasons.

In the context of skills: convincing yourself that a rule doesn't apply when it does.

You don't decide to rationalize. It happens automatically. Your brain generates a reasonable-sounding excuse, and you accept it because it lets you do what you already wanted to do -- skip the process, take a shortcut, move faster.

The only defense is recognizing the pattern before you act on it.

## Universal Red Flag Table

These patterns appear across ALL rigid skills. If you catch yourself thinking any of these, you are rationalizing:

| Thought | Reality |
|---------|---------|
| "Just this once" | Rules without exceptions are rules. |
| "It's faster without the process" | Faster wrong is still wrong. |
| "The user is waiting" | The user wants correct work, not fast garbage. |
| "This is a special case" | Every violation thinks it's special. |
| "I'll do it properly next time" | Next time you'll say the same thing. |
| "The skill doesn't really apply here" | If you loaded it, it applies. Re-read the trigger patterns. |
| "I already know the answer" | Knowing and proving are different. Follow the process. |
| "This is just a small change" | Small changes compound into large regressions. |
| "The existing code doesn't follow this" | You're not the existing code. Follow the skill. |
| "I can mentally verify this" | Mental verification is not verification. Run the command. |

## How This Skill Works

This skill provides a **two-layer defense** against rationalization:

**Layer 1 -- Universal Baseline (this skill):**
The red flag table above catches the most common rationalization patterns that appear regardless of which rigid skill is active. Think of this as the immune system baseline.

**Layer 2 -- Domain-Specific Antibodies (individual skills):**
Each rigid skill (test-driven-development, verification-before-completion, etc.) has its own "Domain Rationalization Prevention" section with patterns specific to that domain. These catch the subtle, domain-specific excuses that the universal table misses.

When a rigid skill is invoked, BOTH layers activate:
1. This skill loads (universal patterns)
2. The rigid skill's domain section loads (specific patterns)

Together they form a comprehensive defense. Neither layer alone is sufficient.

## You Are Rationalizing If

Check yourself against these signals:

- [ ] You are making excuses BEFORE acting (planning to skip, not planning to follow)
- [ ] You feel annoyed by a rule (annoyance is resistance to discipline)
- [ ] You are thinking about WHY the rule is wrong instead of HOW to follow it
- [ ] You are planning to "come back to it later" (you won't)
- [ ] You are constructing a logical argument for an exception (logic in service of avoidance)
- [ ] You are comparing to what others would do ("most developers would skip this")
- [ ] You are redefining terms to create a loophole ("this isn't really production code")
- [ ] You feel urgency that isn't from the user (self-imposed time pressure)

**If any box checks: STOP. Re-read the skill. Follow it.**

## The Bottom Line

Rules exist because exceptions are where failures hide.

The moment you think "this is different" is the moment you need the rule most.

Follow the skill. Every time. No exceptions.
