--- 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.