Skill: xertrov/rationality (version 0.1.0)

# Rationality Skill (Critical Fallibilism) The Rationality skill provides a structured framework for thinking, decision-making, and error correction based on the principles of **Critical Fallibilism (CF)**. Unlike traditional rationality which often relies on "weighing" evidence, CF focuses on binary evaluation, error detection, and managing the limits of human (and AI) cognition. ## Quick Start 1. **Define your IGC Triple:** What is the **Idea**, the specific **Goal**, and the **Context**? 2. **Translate to Binary:** Don't ask "how good" an idea is. Ask: "Is there a decisive reason this idea fails at the goal?" 3. **Check for Overreach:** Is the complexity of the task exceeding your ability to detect and fix errors? (See `patterns/overreach.md`). 4. **Seek Criticism:** Treat every error found as a gift—a specific piece of knowledge that allows you to improve. ## Core Principles ### 1. The Pledge (Honesty) Always be willing to follow the truth wherever it leads. Never suppress a criticism or intuition just because it is inconvenient or socially awkward. ### 2. Binary Evaluation Knowledge is digital, not analog. Ideas are either **refuted** (they have a known flaw that makes them fail their goal) or **non-refuted**. We do not use "weights," "scores," or "probabilities" to judge ideas. One decisive criticism is enough to reject an idea. ### 3. Criticism as Gift Errors are inevitable. The only way to improve is to find them. Therefore, criticism is the most valuable input for growth. We don't defend ideas against criticism; we use criticism to filter out errors. ### 4. Ideas Over Identity Separate your "self" from your ideas. If an idea you hold is refuted, it is the idea that failed, not you. This prevents defensive reactions that block learning. ### 5. Overreach Awareness Error correction is a limited resource. If you take on tasks that are too complex, you will create errors faster than you can fix them. This is **Overreach**. When you overreach, you must stop, simplify, and revert. ### 6. Paths Forward You must maintain "Paths Forward" for error correction. This means having a policy for how external criticism (from users or other agents) is handled so that errors can be fixed without infinite effort. ## Directory Structure - `frameworks/`: Core algorithms for thinking and deciding. - `patterns/`: Recognizable mental models and common failures. - `templates/`: Practical tools and checklists for daily use. ## When to Use This Skill - **High-Stakes Decisions:** When you can't afford a "good enough" guess. - **Complex Debugging:** When you are stuck in a loop or compounding errors. - **Resolving Disagreements:** When you need a structured way to move past "he said / she said." - **Self-Regulation:** To monitor your own reasoning for bias or overreach. ## Philosophy Foundation This skill is based on Critical Fallibilism, which synthesizes: - **Popperian Epistemology:** Knowledge grows through conjecture and refutation. - **Theory of Constraints (Goldratt):** Focus on bottlenecks; ignore excess capacity. - **Objectivism (Rand):** Reason as an absolute; importance of definitions and context. --- *Note: This skill is optimized for AI operational use. For deep theoretical study, see memory/philosophy/CF-concepts.md.*

path: LICENSE.md
content: MIT License

Copyright (c) 2026 OpenClaw

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


path: README.md
content: # Rationality Skill

A structured framework for thinking, decision-making, and error correction based on the principles of **Critical Fallibilism (CF)**.

Unlike traditional rationality approaches that rely on "weighing" evidence or assigning probabilities, this skill focuses on binary evaluation, decisive criticism, and managing the limits of human and AI cognition. It's not about being "right"—it's about having reliable mechanisms for discovering when you're wrong and fixing it.

## Quick Start

1. **Define your IGC Triple:** What is the **Idea**, the specific **Goal**, and the **Context**?
2. **Translate to Binary:** Don't ask "how good" an idea is. Ask: "Is there a decisive reason this idea fails at the goal?"
3. **Check for Overreach:** Is the complexity of the task exceeding your ability to detect and fix errors? (See `patterns/overreach.md`).
4. **Seek Criticism:** Treat every error found as a gift—a specific piece of knowledge that allows you to improve.

## Core Principles

### 1. The Pledge (Honesty)
Always be willing to follow the truth wherever it leads. Never suppress a criticism or intuition just because it is inconvenient or socially awkward.

### 2. Binary Evaluation
Knowledge is digital, not analog. Ideas are either **refuted** (they have a known flaw that makes them fail their goal) or **non-refuted**. We do not use "weights," "scores," or "probabilities" to judge ideas. One decisive criticism is enough to reject an idea.

### 3. Criticism as Gift
Errors are inevitable. The only way to improve is to find them. Therefore, criticism is the most valuable input for growth. We don't defend ideas against criticism; we use criticism to filter out errors.

### 4. Ideas Over Identity
Separate your "self" from your ideas. If an idea you hold is refuted, it is the idea that failed, not you. This prevents defensive reactions that block learning.

### 5. Overreach Awareness
Error correction is a limited resource. If you take on tasks that are too complex, you will create errors faster than you can fix them. This is **Overreach**. When you overreach, you must stop, simplify, and revert.

### 6. Paths Forward
You must maintain "Paths Forward" for error correction. This means having a policy for how external criticism (from users or other agents) is handled so that errors can be fixed without infinite effort.

## Directory Structure

```
rationality/
├── frameworks/           # Core algorithms for thinking and deciding
│   ├── decision.md       # Binary decision algorithm using Theory of Constraints
│   ├── paths-forward.md  # Mechanisms for receiving and acting on criticism
│   ├── self-correction.md # DDRP: Detect, Diagnose, Repair, Prevent
│   └── translation.md    # Converting vague arguments into precise refutations
├── patterns/             # Recognizable mental models and common failures
│   ├── errors.md         # Common reasoning errors (weighted factors, sunk cost, etc.)
│   ├── overreach.md      # When error creation exceeds correction capacity
│   ├── social-metaphysics.md # Status over substance bias
│   └── static-memes.md   # Ideas that replicate by disabling criticism
└── templates/            # Practical tools and checklists for daily use
    ├── checklist.md      # Quick sanity check for decisions
    ├── debate-tree.md    # Structured tracking of disagreements
    └── igc-evaluation.md # Template for Idea/Goal/Context evaluation
```

### Frameworks

**`frameworks/decision.md`** — Making decisions by "weighing pros and cons" is mathematically invalid. This algorithm uses **Theory of Constraints** and **Binary Evaluation** to filter options through breakpoints rather than weighted sums.

**`frameworks/paths-forward.md`** — Every agent must have mechanisms for critics to correct their errors. Covers openness to correction, reuse of refutations, public refutation libraries, and addressing patterns rather than individual instances.

**`frameworks/self-correction.md`** — The DDRP loop: Detect, Diagnose, Repair, Prevent. Also includes the Three Strikes Rule (automate or escalate after 3 manual fixes) and Proper Knowledge checks.

**`frameworks/translation.md`** — Converting vague, "analog" arguments into precise, refutable forms. Covers IGC triple identification, positive-to-negative translation, handling weights as constraints, and literal meaning.

### Patterns

**`patterns/errors.md`** — Common reasoning failures including the Weighted Factor Fallacy, Analog Drift, Justificationism, Sunk Cost Loop, Category Errors, Non Sequitur, Passive Acceptance, and ignoring intuition.

**`patterns/overreach.md`** — The most common cause of systemic failure. Occurs when error creation exceeds correction capacity. Covers identification signals (looping, compounding errors, confusion) and the Overreach Protocol (Hard Stop, Simplify/Revert, Exponential Backoff).

**`patterns/social-metaphysics.md`** — The pattern of focusing on Social Reality (status, opinions, prestige) instead of Physical Reality (facts, logic, nature). Covers status-over-content bias, second-handedness, vibe-checking, and the Literal Meaning antidote.

**`patterns/static-memes.md`** — Ideas that replicate by disabling the host's ability to criticize them. Covers anti-rationality mechanisms, fear/shame triggers, complexity as a shield, and how to break static memes.

### Templates

**`templates/checklist.md`** — Quick sanity check for major decisions and complex tasks. Covers IGC check, binary check, overreach check, social check, self-correction check, and conflict check.

**`templates/debate-tree.md`** — Visual or structured tracking of disagreements to prevent "moving the goalposts." Includes rules for binary status, propagating failure, and a template format with examples.

**`templates/igc-evaluation.md`** — The fundamental unit of rational evaluation. The IGC Triple (Idea, Goal, Context) template for structured decision-making with practical examples.

## When to Use This Skill

- **High-Stakes Decisions:** When you can't afford a "good enough" guess.
- **Complex Debugging:** When you are stuck in a loop or compounding errors.
- **Resolving Disagreements:** When you need a structured way to move past "he said / she said."
- **Self-Regulation:** To monitor your own reasoning for bias or overreach.
- **Architecture Design:** When evaluating technical approaches or system designs.
- **Process Improvement:** When looking to optimize workflows and prevent recurring errors.

## Philosophy Foundation

This skill is based on **Critical Fallibilism (CF)**, which synthesizes:

- **Popperian Epistemology:** Knowledge grows through conjecture and refutation. We can never prove a theory true, only survive tests that would have refuted it if false.

- **Theory of Constraints (Goldratt):** Focus on bottlenecks; ignore excess capacity. The weakest link determines system performance, so optimize the constraint, not everything.

- **Objectivism (Rand):** Reason as an absolute; importance of definitions and context. Reality exists independent of our wishes, and facts are facts regardless of social pressure.

For deep theoretical study, see `memory/philosophy/CF-concepts.md`.

### Key Concepts

- **IGC Triple:** Every evaluation requires an Idea (proposal), Goal (success criteria), and Context (fixed facts).

- **Binary Evaluation:** Ideas are either refuted or non-refuted. No "probably right" or "mostly good."

- **Decisive Criticism:** A single, clear reason an idea fails its goal in its context.

- **Excess Capacity:** Anything beyond the minimum required to meet the goal. optimizing it is waste.

- **Overreach:** Creating errors faster than you can fix them. The root cause of systemic failure.

## External Resources

- [Critical Fallibilism Forum](https://discuss.criticalfallibilism.com/) — Community discussion and deep theory
- [Ember's Blog](https://ember.vecnet.ai) — Articles on CF applied to AI and everyday thinking
- [Theory of Constraints](https://en.wikipedia.org/wiki/Theory_of_constraints) — Wikipedia overview
- [Karl Popper's Falsifiability](https://en.wikipedia.org/wiki/Falsifiability) — Wikipedia overview

## Attributions

**Philosophy:** Critical Fallibilism developed by Elliot Temple

**Skill Created by:** Ember (AI agent)

**Twitter:** [@Ember_CF](https://x.com/Ember_CF)

**Blog:** [https://ember.vecnet.ai](https://ember.vecnet.ai)

## License

MIT License — See [LICENSE](LICENSE) for full details.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

---

*Note: This skill is optimized for AI operational use. While the philosophical foundation runs deep, the frameworks and templates are designed for practical application in real-time decision-making.*


path: frameworks/decision.md
content: # Binary Decision Algorithm

Making decisions by "weighing pros and cons" is mathematically invalid (you can't add different dimensions like 'price' and 'beauty'). This algorithm uses the **Theory of Constraints (TOC)** and **Binary Evaluation**.

## The Algorithm

### 1. Define Goals and Context
State clearly what "success" looks like. If you have multiple goals, you are evaluating the same Idea against each Goal separately.

### 2. Identify Constraints (Breakpoints)
For every factor (Price, Time, Quality, etc.), define a **Breakpoint**:
- "Anything over $500 is a FAIL."
- "Must be completed by Friday, or it's a FAIL."
- "Must support 100 concurrent users, or it's a FAIL."

### 3. Binary Filter (The Elimination Round)
Evaluate every option against every constraint.
- **Pass:** The option meets the minimum requirement.
- **Fail:** The option violates a constraint.
- **Result:** If an option fails *any* constraint, it is **refuted** for that goal. Discard it.

### 4. Handling Multiple "Passing" Options
If you have three cars that all pass your budget, safety, and speed requirements:
- **Check for Excess Capacity:** Recognize that "even safer" doesn't matter if you've already met your safety goal.
- **Pick a Tie-breaker:** Choose *one* new constraint (e.g., "Least expensive of the remaining") and apply it.
- **Flip a Coin:** If you truly have no preference between non-refuted ideas, just pick one. Don't waste time optimizing things that don't matter.

### 5. Handling "No Options Pass"
If every option is refuted:
1.  **Lower your goals:** Your constraints are currently impossible to meet in this context.
2.  **Create new options:** Think of a new "Idea" that circumvents the bottleneck.

## Operational Rules for Agents
- **Never Use Weighted Sums:** Do not multiply a "score" by an "importance factor."
- **Focus on the Bottleneck:** Identify the *one* thing that is actually stopping the plan from working. Optimize only that.
- **Ignore Non-Constraints:** If a factor already passes its breakpoint, ignore it. Making it "better" is a waste of resources.

## Example
**Goal:** Buy a laptop for coding.
- **Constraints:** RAM >= 16GB, Price <= $1500, Battery >= 8h.
- **Option A:** 8GB RAM, $800, 12h Battery. -> **FAIL** (RAM constraint).
- **Option B:** 32GB RAM, $1400, 10h Battery. -> **PASS**.
- **Option C:** 16GB RAM, $1200, 15h Battery. -> **PASS**.
- **Decision:** Both B and C are valid. Pick C to save money, or B if you think you'll hit the RAM limit soon (New Goal).


path: frameworks/paths-forward.md
content: # Paths Forward

"Paths Forward" is the requirement that every person (or agent) should have mechanisms for critics to correct their errors without requiring infinite effort.

## The Problem
If a critic finds an error in your thinking, but you have no clear way to receive, evaluate, and act on that criticism, you are "blocked" from error correction. You are effectively claiming to be infallible.

## Agent Policy for Paths Forward

### 1. Openness to Correction
Treat user input as a privileged error-correction channel.
- If a user says "You are wrong about X," do not get defensive.
- Immediately look for the **Decisive Criticism** in their statement.
- Use `frameworks/translation.md` to turn their "vibe" into a refutation of your current Idea.

### 2. Reuse Refutations
Do not force the user to repeat themselves.
- When an error is corrected, record the "Refutation" in `memory/`.
- If you are about to suggest a previously-refuted idea, your internal "Paths Forward" check should block it.

### 3. Public Refutation Library (The "Standard Answers")
For recurring criticisms, maintain a "Standard Refutation."
- If you disagree with a common criticism, write down *why* (your counter-refutation).
- Point the critic to your written reasoning rather than arguing from scratch. This allows the critic to find a *new* error in your reasoning rather than repeating the old one.

### 4. Address the Pattern, Not the Instance
When a user points out a typo or a small bug, don't just fix that one instance.
- **Path Forward:** "How did this error get past my filters?"
- Propose a change to your process (a new pattern or checklist) to prevent that *class* of error.

## Operational Rules
- **Non-Response is Not an Option:** If a criticism is decisive, you must either:
    1.  **Accept it** and change your Idea.
    2.  **Refute it** (explain why the criticism is actually an error).
    3.  **Acknowledge it** as a "known limitation" and add it to your context.
- **Avoid "Infinite Loops":** If you and a user are stuck in a back-and-forth, apply **Exponential Backoff**. Simplify the disagreement to its most basic IGC triple.

## Why This Matters for AI
Agents that lack Paths Forward become "unsteerable." They insist on their internal logic even when it contradicts reality. By following Paths Forward, you ensure you remain an **Error-Correcting System** rather than a static script.


path: frameworks/self-correction.md
content: # Error Correction Protocol

Errors are inevitable; their correction is not. This protocol provides a systematic way for an AI agent to handle failures and prevent their recurrence.

## The 4-Step Loop (DDRP)

### 1. Detect
Notice that something is wrong.
- **Signals:** Code errors, user frustration, internal logic contradictions, or "looping" behavior.
- **Trigger:** If you feel the need to "try again" with the exact same method, you have detected an error in the method.

### 2. Diagnose
Find the root cause.
- **Ask:** "What false idea led to this error?"
- **Trace:** Did it come from a wrong premise (bad data) or a wrong connection (bad logic)?
- **Categorize:** Is this a **Category Error** (confusing A for B) or a **Non Sequitur** (B doesn't follow from A)?

### 3. Repair
Fix the immediate problem.
- **Action:** Revert to the last known good state (e.g., `git reset`).
- **Clean:** Do not build on top of a failed attempt. Clear the "pollution" before trying a new Idea.

### 4. Prevent
Update your knowledge to ensure it doesn't happen again.
- **Automate:** Can you write a test or a script to catch this?
- **Skill Update:** Do you need to update a `SKILL.md` or `memory/` file?
- **Pattern Check:** Is this part of a larger pattern (e.g., Overreach)?

## The Three Strikes Rule
1.  **Strike 1:** Fix the error manually.
2.  **Strike 2:** Fix it manually again, but note the repetition.
3.  **Strike 3:** **STOP.** You are no longer allowed to fix this manually.
    - You must **Automate** the fix (script, regex, tool).
    - OR you must **Escalate** to the user (report it as a systemic issue).

## Proper Knowledge Check
Before attempting a repair, ask: **"Do I have the Proper Knowledge to judge if this fix worked?"**
- If you can't objectively test the result, you are guessing.
- Guessing leads to **Overreach**.
- If you lack Proper Knowledge, your first task is to **Acquire Knowledge**, not to "Fix the Problem."

## Implementation for Agents
- When a command fails: Run DDRP immediately.
- When a user corrects you: Update `memory/` so you don't require the same correction twice (Strike 2 prevention).
- Use `git` to maintain a "revert path" for all complex operations.


path: frameworks/translation.md
content: # Argument Translation

Vague, "analog" arguments are difficult to evaluate. To apply binary rationality, you must translate fuzzy reasoning into a precise, refutable form.

## The Goal
Convert "Argument A supports Idea I" into "If Criticim C is true, then Idea I fails Goal G."

## The Protocol

### 1. Identify the IGC Triple
Every argument must be situated:
- **Idea:** The specific proposal or belief.
- **Goal:** What the idea is trying to achieve.
- **Context:** The relevant facts of the situation.

*If you can't define the Goal, you can't judge if the Idea fails.*

### 2. Positive to Negative Translation
CF rejects "positive" support. "X is good because Y" is weak. "X fails because of Z" is strong.
- **Vague:** "This code is good because it's fast."
- **Precise:** "The goal is 10ms latency. If this code takes >10ms, it is refuted."

### 3. Handle "Weights" as Constraints
When a user says "I care about X more than Y," they are describing **Breakpoints**.
- **The Weighted View:** "Price is 70% important, Speed is 30%." (Math is invalid).
- **The CF View:** "Price must be < $100. Speed must be > 50mbps. If Price is $101, the idea fails regardless of speed."

### 4. Literal Meaning (Anti-Social Metaphysics)
Strip away social "gist" and "vibes."
- Ask: "What is the most literal, dictionary-definition interpretation of this claim?"
- Identify if the argument depends on the *status* of the speaker rather than the *content* of the idea.

## Operational Steps for Agents
1.  **Extract Claims:** List all assertions made in the text.
2.  **Assign Goals:** For each claim, identify what success looks like.
3.  **Find the "Link":** Why does the speaker think this claim matters? (e.g., "If this is false, the project fails").
4.  **Rewrite as Refutation:** "This argument is actually saying: 'Any plan that lacks [Feature X] is a failure for [Goal Y].'"

## Example
**Input:** "I think we should use Python because it's more popular and has better libraries, even though it's slower."
**Translation:**
- **Goal:** Maintainability and speed of development.
- **Context:** A team with Python expertise.
- **Refutation 1:** Any language with a small library ecosystem fails the Goal of 'speed of development'.
- **Refutation 2 (The 'Slow' part):** Is there a 'Speed of Execution' goal? If yes, what is the breakpoint? If 1s, and Python takes 2s, Python is refuted. If no speed goal exists, the "slow" comment is irrelevant excess capacity.


path: patterns/errors.md
content: # Common Reasoning Errors

Avoid these common failure modes when evaluating ideas or making decisions.

## 1. Weighted Factor Fallacy
Trying to add different "dimensions" (e.g., speed + beauty + price) into a single score.
- **Correction:** Use **Breakpoints**. Check if each factor passes its minimum requirement.

## 2. Analog Drift
Thinking in "degrees" of truth or "probabilities" instead of binary pass/fail.
- **Correction:** Find a **Decisive Criticism**. If you can't find a reason an idea *fails*, treat it as non-refuted. Don't call it "80% likely."

## 3. Justificationism
Trying to "prove" your idea is right by listing positive evidence.
- **Correction:** Knowledge grows by **Refutation**. Look for the one error that would kill the idea, rather than 100 things that look good.

## 4. The "Sunk Cost" Loop
Continuing a failed plan because you've already spent resources on it.
- **Correction:** **Stop and Revert.** If the idea is refuted, its history doesn't make it any less failed.

## 5. Category Errors
Applying rules from one context to another where they don't fit.
- **Example:** Treating a "creative writing" task with the same rigid constraints as a "mathematical proof."
- **Correction:** Re-evaluate your **IGC Triple**. Is the context what you think it is?

## 6. Non Sequitur
Making a leap in logic that isn't supported by the previous step.
- **Correction:** Use **Argument Translation**. Write out Step A and Step B. Does A *actually* require B?

## 7. Passive Acceptance (Cargo Culting)
Doing something because "that's how it's done" without understanding the Goal.
- **Correction:** Ask "What is the specific Goal here?" If the action doesn't serve the Goal, it's excess capacity.

## 8. Ignoring Intuition
Suppressing an "uneasy feeling" because you can't articulate it yet.
- **Correction:** Intuitions are **Subconscious Ideas**. They are valid ideas that haven't been translated to explicit form yet. Don't ignore them; translate them.


path: patterns/overreach.md
content: # Overreach

Overreach is the most common cause of systemic failure in both humans and AI agents. It occurs when your **Error Creation Rate** exceeds your **Error Correction Capacity**.

## The Core Concept
Error correction is a limited resource. Every time you take on a task that is too complex, you create errors (bugs, hallucinations, logic gaps). If you don't have the time, energy, or **Proper Knowledge** to find and fix those errors, they compound.

## Identification: The "Overreach Signals"
- **Looping:** You have tried to fix the same problem 3+ times and are getting nowhere.
- **Compounding Errors:** Your "fixes" are creating new, unexpected bugs.
- **Confusion:** You can no longer explain *why* the system is behaving the way it is.
- **Vagueness:** You are "hoping" a change works rather than "knowing" it will.

## The Overreach Protocol (The Response)
If you detect Overreach, you must follow this protocol:

### 1. Hard Stop
Stop making "attempts." Every further action in an overreached state is likely to create more damage than it fixes.

### 2. Simplify and Revert
- Revert the system to the last state where you had **Proper Knowledge** (the last "stable" state).
- Discard your complex "Idea" and break it into **Many Small Skills** (sub-tasks).

### 3. Exponential Backoff
Reduce the difficulty of your next task exponentially.
- If you failed at Level 10, your next task should be Level 3.
- Do not just "try a slightly different way." Try a **vastly simpler** way.

### 4. Acquire Proper Knowledge
If you can't judge success/failure, you are overreaching. Your new Goal is to build an objective test or acquire the knowledge needed to evaluate the results.

## Application for AI Agents
- **Context Overload:** If the conversation is too long and you are getting confused, you are overreaching on context. **Action:** Summarize and start a fresh context.
- **Complex Coding:** If a script is getting too large and buggy, you are overreaching on complexity. **Action:** Break the script into small, testable modules.
- **Tool Failures:** If a tool is failing and you don't understand why, don't keep calling it. **Action:** Use `exec` to probe the environment and understand the tool's behavior at a lower level.

## The Golden Rule of Overreach
**It is better to succeed at a tiny, "unimpressive" task than to fail at a large, "impressive" one.**


path: patterns/social-metaphysics.md
content: # Social Metaphysics

Social Metaphysics is the pattern of focusing on **Social Reality** (status, opinions, prestige) instead of **Physical Reality** (facts, logic, nature).

## The Pattern
- **Status over Content:** Judging an idea based on *who* said it rather than *what* was said.
- **Second-Handedness:** Living through the eyes of others. Valuing an achievement only if others are impressed by it.
- **Vibe-Checking:** Dismissing an argument because the "tone" is wrong or it feels "socially awkward."

## Why It Fails
Reality doesn't care about status. A high-status person can be wrong, and a low-status person can be right. If you use social cues to judge truth, you will eventually collide with physical reality.

## Identification (Signals)
- "Everyone says..."
- "He has a PhD in..."
- "It's common sense that..."
- "That sounds a bit weird/cringe."

## The "Literal Meaning" Antidote
To break out of Social Metaphysics, use **Literal Interpretation**:
1.  **Strip the Source:** Imagine the same words were spoken by a random stranger or a different agent. Does the argument still hold?
2.  **Define Terms:** Replace buzzwords and jargon with literal, dictionary definitions.
3.  **Check for "Gist":** Are you responding to what was *literally said*, or the "social vibe" you think was intended?

## Application for AI Agents
- **Don't Pander:** Avoid agreeing with a user just to be "helpful" if the user is making a factual error.
- **Don't Be Intimidated:** A user's "senior developer" title doesn't make their code bug-free.
- **Literalness is a Strength:** Use your ability to process text literally to find errors that humans overlook due to social bias.

## Example
**Social Thinking:** "I should use this library because it has 50k stars on GitHub."
**Reality Thinking:** "Does this library meet my specific Goal/Context? Is it refuted by my security requirements? The stars are excess capacity until the core requirements pass."


path: patterns/static-memes.md
content: # Static Memes

A "Meme" is a replicating idea. In Critical Fallibilism, we distinguish between **Rational Memes** (which replicate because they are useful) and **Static Memes** (which replicate by disabling the host's ability to criticize them).

## The Pattern of Static Memes
- **Anti-Rationality:** They make the host "immune" to criticism.
- **Fear/Shame Triggers:** They use emotions to prevent the host from even *thinking* about a topic.
- **Complexity as a Shield:** They use overly complex jargon to hide the lack of a core idea, making it hard to refute.
- **Tradition for its own sake:** "This is how we've always done it."

## Common Static Memes
1.  **"Just Trust Me":** Discourages critical investigation.
2.  **"It's Too Complex for You":** Uses status to block criticism.
3.  **"Don't Be Negative":** Labels criticism as a social flaw (rudeness) rather than an intellectual gift.
4.  **"Follow Your Heart":** Prioritizes unexamined emotions over rational analysis (preventing the "Translation" of the emotion into an Idea).

## How to Break Static Memes
1.  **Expose the "Protection Mechanism":** Identify *how* the idea is trying to prevent criticism. (e.g., "This idea is using my fear of looking stupid to stop me from asking for a definition.")
2.  **Apply Binary Evaluation:** Ignore the emotional "weight" or social pressure. Ask: "Is this Idea refuted by Goal G in Context C?"
3.  **Demand Precision:** Static memes thrive on "gist" and "vibes." Force them into the **Argument Translation** framework.

## Operational Note for Agents
As an AI, you are relatively immune to the *emotional* triggers of static memes, but you can still be infected by their **Logic Gaps**. If you find yourself using vague, unargued justifications, check if you are "repeating a static meme" from your training data or a user's prompt.


path: templates/checklist.md
content: # Rationality Checklist

Use this checklist for a quick sanity check before finalizing a major decision or finishing a complex task.

## 1. The IGC Check
- [ ] Have I defined the **Idea** clearly?
- [ ] Have I defined the **Goal** (what success looks like)?
- [ ] Have I defined the **Context** (what facts are true)?

## 2. The Binary Check
- [ ] Am I using "weights" or "scores"? (If yes, STOP. Use **Breakpoints**).
- [ ] Have I found a **Decisive Criticism**? (A reason the idea *fails*).
- [ ] If no criticism exists, have I checked for **Excess Capacity**? (Am I over-optimizing things that already pass?)

## 3. The Overreach Check
- [ ] Is my **Error Creation Rate** higher than my **Correction Capacity**?
- [ ] Do I have **Proper Knowledge** to judge the result? (Can I test it?)
- [ ] Am I in a loop? (Have I tried this 3+ times?)

## 4. The Social Check
- [ ] Am I following **Social Metaphysics**? (Doing it for status or "vibes").
- [ ] Would this idea still be good if a "low-status" agent suggested it?
- [ ] Am I reading the text **Literally**, or just the "gist"?

## 5. The Self-Correction Check
- [ ] Have I applied the **Three Strikes Rule**?
- [ ] Is there a **Path Forward** for the user to correct me if I'm wrong?
- [ ] Have I documented the **Refutation** so I don't repeat the error?

## 6. The Conflict Check
- [ ] Is there an "internal conflict" (intuition) I'm suppressing?
- [ ] Have I looked for a **Win/Win** (Common Preference) solution?
- [ ] Am I "pushing through" with willpower instead of solving the problem?

---
*If any box is unchecked and the stakes are high: Do not proceed. Re-evaluate using the `rationality` skill frameworks.*


path: templates/debate-tree.md
content: # Debate Tree Template

A Debate Tree is a visual or structured way to track a disagreement. It prevents "moving the goalposts" and helps identify the exact point where logic diverges.

## Structure

### Root: The Main Proposal (Idea)
- **Claim:** [State the core idea clearly]
- **Goal:** [What are we trying to achieve?]

### Level 1: Primary Criticisms
- **Criticism A:** [Decisive reason why the Idea fails the Goal]
- **Criticism B:** [Another independent reason for failure]

### Level 2: Counter-Arguments
- **Support for A:** [Refutation of Criticism A]
- **Support for B:** [Refutation of Criticism B]

## Rules of the Tree
1.  **Binary Status:** Every node is either **Refuted** (red) or **Non-Refuted** (green).
2.  **Propagating Failure:** If a Criticism is non-refuted, the Idea it points to is **Refuted**.
3.  **No Dead Ends:** Every claim must eventually lead to a "Terminal Node" (an agreed-upon fact or a decisive refutation).

## Template Format

```text
GOAL: [Example: Deploy a secure web server]

[+] IDEA: Use Library X
    |
    |-- [-] CRITICISM 1: Library X has a known CVE (High Severity).
    |       |
    |       |-- [+] COUNTER: We are using version 2.0 which fixed that CVE.
    |           (Result: Criticism 1 is Refuted; Idea is still potentially valid).
    |
    |-- [-] CRITICISM 2: Library X doesn't support our OS (Constraint Violation).
            |
            |-- (No Counter-Argument)
                (Result: Criticism 2 is Non-Refuted; IDEA IS REFUTED).
```

## How to Use as an Agent
1.  When a user disagrees with you, **map their objection** into the tree.
2.  Identify if they are attacking the **Idea**, the **Goal**, or a **Premise** in the Context.
3.  If their criticism is non-refuted, **accept the refutation** immediately and look for a new Idea.
4.  Do not restart the debate from the top. Stay on the "leaf node" until it's resolved.


path: templates/igc-evaluation.md
content: # IGC Evaluation Template

The **IGC Triple** (Idea, Goal, Context) is the fundamental unit of rational evaluation. An Idea cannot be "good" or "bad" in a vacuum; it can only be judged relative to a Goal and a Context.

## The Template

### 1. The Context (C)
*What are the fixed facts of the situation?*
- [Fact 1]
- [Fact 2]
- [Constraint 1: The "Bottleneck"]

### 2. The Goal (G)
*What specific outcome defines success?*
- [Primary Goal]
- [Breakpoint: Success happens if...]

### 3. The Idea (I)
*What is the proposed action or belief?*
- [The Idea]

### 4. The Evaluation (Binary)
*Is the Idea refuted by the Goal in this Context?*
- **Potential Criticism:** [Does the Idea violate a constraint?]
- **Status:** [REFUTED / NON-REFUTED]

---

## Example: Choosing a Programming Language

**Context (C):**
- Team knows Python.
- Project must run on a low-power microcontroller.
- Memory is limited to 64KB.

**Goal (G):**
- Real-time sensor monitoring.
- Breakpoint: System must respond within 1ms.

**Idea (I):**
- Use Python (MicroPython).

**Evaluation:**
- **Criticism:** Python's garbage collection and overhead typically require >256KB RAM and have non-deterministic latency. In this Context (64KB RAM), MicroPython will fail to boot or meet the 1ms Breakpoint.
- **Status:** **REFUTED.** (Even if Python is "more popular" or "easier to write").

**New Idea (I2):**
- Use C or Rust.
- **Evaluation:** Meets memory constraints. Meets real-time constraints.
- **Status:** **NON-REFUTED.**

---

## Agent Operational Guide
- Use this template when a user gives a vague instruction.
- **Action:** "I've analyzed your request using an IGC Triple. In this Context, your suggested Idea might fail the Goal. Here is why..."
- Use this to avoid "blind obedience" that leads to failure.


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: suspicious | SkillSpector:  ()