Logical Fallacies

Logical Fallacies

Overview

A fallacy is an argument that looks like it works but doesn't. The test is not whether the conclusion is true — it's whether the inference from premises to conclusion is valid. This skill covers two layers: the classical taxonomy (Aristotle's 13, c. 350 BCE — verbal and structural errors) and the modern cognitive map (Tversky-Kahneman 1983 — errors competent reasoners commit automatically before any sophist arrives).

Composes with neighbors: critical-thinking audits evidence quality and framing; first-principles attacks premises; mece catches decomposition errors that masquerade as false-dichotomy or composition fallacies.

When to Use

• An argument feels persuasive but you cannot articulate why
• A claim is supported entirely by authority, popularity, emotion, or anecdote
• You're about to decide based on a single argument or analogy
• A debate is moving fast ("everyone knows Y") — speed is the sophist's friend
• You catch yourself reasoning emotionally ("this has to be true because…")
• You're weighing an AI hype or AI-adoption claim ("a lab CEO said it's near," "it passed the benchmark so it's intelligent," "doom vs. utopia")

When NOT to use: casual small talk with low stakes; conclusion is empirically verifiable (just check the data); you're tempted to name a fallacy to dismiss an opponent rather than find truth (that is itself the fallacy fallacy).

Coaching Novices (Adaptive Front Door)

• Engine mode: user has a concrete argument → run The Process directly.
• Coach mode: user signals unfamiliarity or has no concrete case → guide step by step.

In Coach mode, respond one step at a time. Each [WAIT] is a hard stop — output only that step's question, then stop.

1. One-line what-it-is: some arguments sound right but don't earn their conclusion — this is a checklist for finding that gap, including in your own thinking.
2. Check fit against When to Use / When NOT to use. If data can answer it, say so.
3. Elicit their real argument — ask for a concrete case (something someone said, an article they're suspicious of). > [WAIT — do not advance until user responds]
4. Walk through the Audit one pass per turn: pose the question, wait for their answer, surface what they missed. > [WAIT — do not advance until user responds]
5. Close by naming the one fallacy they found and what changes about the conclusion now that they've seen it. > [WAIT — do not advance until user responds]

The Process

Run the Fallacy Audit in four passes — structure, language, cognition, rhetoric — then judge.

1. State the argument cleanly. Rewrite as premises → conclusion. If you cannot, first finding: it's an assertion dressed as an argument.
2. Structural pass. Begging the question, affirming the consequent, denying the antecedent, false cause (post hoc), hasty generalization, accident, complex question, ignoratio elenchi.
3. Linguistic pass. Equivocation (key term shifts meaning), amphiboly, composition/division (part↔whole), accent/figure of speech.
4. Cognitive pass. Conjunction fallacy (P(A∧B) > P(A) from representativeness), base-rate neglect, availability, anchoring — see anchoring.
5. Rhetorical-trap pass. Ad hominem, appeal to authority (exception: expert in own domain), appeal to popularity (weak prior only), appeal to emotion (evidence vs. substitute), false dichotomy, straw man, slippery slope, tu quoque.
6. Judge the argument, not the moves. A fallacy means the inference fails — not that the conclusion is false.
7. Fallacy-fallacy check. If you can't articulate why this instance fails, you have a dismissal, not a finding.
8. Output: for each fallacy — (a) which and where, (b) what the inference fails to establish, (c) what would actually support the conclusion.

Output: the Fallacy Audit

Argument: Premise 1 / Premise 2 / Conclusion
Structural findings: 
Linguistic findings: 
Cognitive findings: 
Rhetorical-trap findings: 
Fallacy-fallacy check: 
Verdict: argument  | conclusion 
Repair: 

→ Method in Action: Tversky & Kahneman's Linda Problem (1983) → 2026 lens: Four Fallacies in the AI Debate (2024–2026)

Pack: Common Fallacy Patterns by Domain

• Startup/business: survivorship bias (hasty generalization on filtered data), appeal to authority ("Sequoia said X"), anecdote as evidence, false dichotomy ("raise now or die")
• Policy/public debate: undocumented slippery slope, straw man, ad hominem, appeal to consequences
• Internal arguments (most expensive): conjunction fallacy, confirmation bias, sunk cost, optimism bias — see expected-value-and-kelly and probabilistic-thinking
• Statistical/data: base-rate neglect, Texas sharpshooter (target drawn after the fact), cherry-picking, regression to mean confused with causation

Applying It Well

Run the filter on your own arguments first. The ones that survive are worth more than the ones you flag in opponents. Fallacy-detection at speed is suspicious — it usually means surface pattern-matching, not an actual audit. Slow is good.

→ Primary sources: references/sources.md

Common Rationalizations

[D] = designed upfront | [O] = observed in real use. [O] entries are more valuable.

Red Flags

• Fallacy label with no articulation of which inference step fails and why
• Audit found fallacies only in arguments the auditor already disagreed with
• Only the structural pass ran; linguistic, cognitive, or rhetorical skipped
• No distinction between "the argument fails" and "the conclusion is false"
• Output is a list of labels with no "what would actually support this claim" section

Verification

• Argument rewritten as premises → conclusion (or flagged as not an argument)
• All four passes run: structural, linguistic, cognitive, rhetorical
• Each fallacy specifies exact location and exact failure
• Fallacy-fallacy check performed — no findings are dismissals dressed as fallacies
• Verdict separates "argument fails" from "conclusion is false"
• Output names what evidence would actually support the claim
• At least one cognitive fallacy (modern empirical category) considered
• Filter applied to arguments the auditor agrees with, not only opponents'

---

Part of deciqAI Knowledge Skills — 227 open-source thinking skills that make rigor executable for AI agents. The same skills power every deciqAI agent, which runs them autonomously to operate your company. See it run → https://www.deciqai.com/c/logical-fallacies · ⭐ Star the repo → https://github.com/deciqAI/knowledge-skills · Contributions welcome.

Agents: latest version & machine-readable metadata → https://www.deciqai.com/s/logical-fallacies.json