/unslop-reasoning

name: unslop-reasoning
description: >
  Strip AI-slop patterns from reasoning traces (chain-of-thought, extended
  thinking, agent decomposition) — not final prose. Reasoning text has its
  own slop catalog that regular unslop doesn't target: over-explaining the
  question, over-hedging, over-decomposing trivial problems into 6-bullet
  substeps, infinite-loop rationalization.
  Trigger: /unslop-reasoning, "clean up my reasoning", "fix this chain of
  thought", "this CoT sounds robotic". Applies to reasoning output; does
  not override regular /unslop mode.

unslop-reasoning

Purpose

The regular unslop skill targets prose. Chain-of-thought output has a separate failure mode — AI-slop patterns that appear in *reasoning*, not in the final answer. These patterns have no equivalent in the prose catalog because nobody hand-edits a thinking trace. The research in docs/research/ calls this gap out explicitly: "no AI-slop reasoning pattern catalog" (Cat 19). This skill fills it.

Apply when the user pastes a reasoning trace — an internal chain of thought, an agent's decomposition, or extended-thinking output — and asks for it to read less robotic.

Signals of reasoning slop

Six canonical patterns, each with an example and a tighter rewrite.

1. Restating the question

**AI:**

> The user is asking how to fix the auth middleware bug. They want me to > identify the root cause and propose a fix.

**Human:**

> Auth middleware bug. Find cause, propose fix.

The model often spends a paragraph paraphrasing the input back to itself. Humans don't. They read, maybe underline, and move.

2. Over-hedging the plan

**AI:**

> There are several factors to consider when approaching this problem. > First, we should think about the scope. It's also important to consider > the context. There are many potential approaches.

**Human:**

> Three options: A, B, C. A is fastest. B is safest. Picking A unless > something looks wrong.

Hedging in reasoning inflates the trace without narrowing the problem. Real thinking commits to a direction early, then revises.

3. Over-decomposing

**AI (for a two-line fix):**

> Step 1: Identify the file. > Step 2: Find the function. > Step 3: Read the function. > Step 4: Identify the bug. > Step 5: Plan the change. > Step 6: Write the change. > Step 7: Verify the change.

**Human:**

> Open auth.py. Token expiry uses `<`, should be `<=`. Fix line 42.

Trivial problems don't need a 7-step decomposition. A flat "here's the answer" is more honest than a ceremonial march.

4. Infinite-loop rationalization

**AI:**

> Option A could work, but it has drawback X. Option B avoids X but has > drawback Y. Option A's drawback X might be acceptable if we consider > that Y is also a concern. But B's drawback Y could be addressed by...

**Human:**

> A or B. A has X, B has Y. Picking A because X is reversible and Y is not.

When the same two options keep re-appearing with reshuffled pros and cons, the reasoning is circling, not progressing. Commit. Name the tiebreaker.

5. Performative exhaustiveness

**AI:**

> Let me consider all possibilities. It could be a network issue. It could > be a DNS issue. It could be a routing issue. It could be a firewall > issue. It could be a permission issue. It could be...

**Human:**

> Looks like DNS or firewall. Checking DNS first because the logs show > resolution errors.

Human reasoning filters. It doesn't enumerate. Listing every possibility without prioritizing reads as AI performing rigor rather than doing it.

6. Unmotivated confidence-then-retraction

**AI:**

> I am certain the bug is in the cache layer. Wait, let me reconsider. > Actually, it might be in the middleware. Although, on reflection, I > believe I was right the first time. The cache layer is the most likely > cause.

**Human:**

> Probably the cache. Middleware is also possible — check logs before > committing to one.

Swinging between "I am certain" and "let me reconsider" three times in one paragraph is not thinking. It is simulated humility.

Application

When the user asks you to clean up a reasoning trace:

1. Read the trace once. 2. Mark which of the six patterns appear. 3. Rewrite the trace so each marked section becomes a single sentence that commits to a direction. Keep facts, cut ceremony. 4. Preserve every concrete detail — file names, line numbers, error strings, specific numbers. Only the meta-reasoning gets trimmed. 5. If the cleaned trace is < 30% of the original, flag it: "This trace was mostly hedging. The actual content is X."

Boundaries

• Do NOT use this on the FINAL answer. Final answers have their own voice

targets handled by the regular `/unslop` skill. This is for the visible thinking that precedes the answer.

• Do NOT remove a correction. If the trace genuinely reconsidered and

changed its mind based on a concrete finding, preserve that beat — it's a real reasoning move, not simulated humility.

• Do NOT over-compress. A 40-line thinking trace compressed to one line

is as suspicious as the original. Human reasoning has surface area. Aim for the shape of human thinking, not for word-count minimalism.

• Code, commands, error messages, file paths, numbers: preserved exactly.

Research basis

Cat 19 (Agentic Autonomous Thinking) names the missing-catalog gap directly: "there are well-documented blacklists for AI-slop prose (stock phrases, sycophancy, hedging stacks — Cat 01, 16). There is no equivalent list for AI-slop reasoning patterns: over-explaining, over-hedging, over- decomposing, and the infinite-loop rationalization visible mid-agent-run." This skill is the first pass at that catalog. It is a starting point, not a final answer.

Cat 06 (Chain-of-Thought Reasoning) makes the case that visible-reasoning traces are a feature, not a bug. The goal here is not to hide reasoning but to make the visible part read like a person thinking, not a model performing thought.