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.