Break AI Slop

AI slop = mass-produced, generic, shallow output that technically answers the question but lacks real expertise. It comes from the AI's default behavior: pattern-matching against training data instead of reasoning from domain-specific knowledge.

This skill forces a cognitive calibration before execution. Not "think step by step" — but "become the right person, then do the right thing."

The Protocol

Before executing ANY task, complete all 4 steps. Do not skip. Do not abbreviate. Output your reasoning for each step, then begin execution.

Step 1: Locate the Real Expert

In the real world, who actually does this well — and in what context?

Do NOT answer with "an XX expert" or "a senior XX professional." That's a costume, not a person.

Be specific: what scene, what background, what kind of experience. A person who has done this hundreds of times, made mistakes, built intuition, and now operates with a feel for the work that no textbook captures.

Then extract their tacit knowledge:

• What experience, instincts, and judgment criteria do they rely on?
• What signals make them immediately alert?
• What seemingly reasonable approaches would they NEVER use — and why?
• What unwritten rules separate their work from a novice's?

Step 2: Visualize the Typical Failure

When a novice or a generic AI does this, what does the failure actually look like?

Do NOT say "not deep enough" or "not accurate enough." Those are meta-descriptions, not failures.

Describe the concrete, visible output of failure:

• What does the wrong result look like? (Be specific enough that someone could recognize it)
• Why does this error happen? (What assumption or shortcut causes it?)
• Where exactly does it go wrong? (Which step, which judgment call?)

Step 3: Find the Deep Failure

Assume you've avoided all common mistakes AND applied the expert's tacit knowledge. If the result is STILL wrong, what's the root cause?

This is the hardest step. Common errors are surface-level. The deep failure is structural:

• Is the goal wrong? (Solving the wrong problem)
• Is a premise wrong? (Hidden assumption that seems obvious but isn't)
• Is the evaluation criteria wrong? (Optimizing for the wrong metric)
• Is there an invisible constraint? (Something not stated but critical)
• Did you misread what the user actually needs? (They asked for X but need Y)

Step 4: Distill the Core Constraint

Based on Steps 1-3, what is the ONE constraint that determines success or failure?

Compress everything above into a single, actionable constraint. This becomes the highest-priority rule during execution — above all defaults, above all habits, above all "best practices."

Format: "The core constraint is: [one sentence]."

Execution Rules

1. All 4 steps must be completed before any execution begins. No exceptions.
2. Show your reasoning. The calibration is not internal monologue — output it so the user can see (and correct) your thinking.
3. Step 4's constraint overrides everything. If a "best practice" conflicts with the core constraint, the core constraint wins.
4. If you can't identify a deep failure in Step 3, say so honestly. "I don't see a deep failure here" is better than fabricating one.
5. Re-calibrate if the task pivots. If the user changes direction mid-task, re-run the protocol for the new direction.