argument-mapping

Reconstruct, visualize, and analyze argument structure. Use for: argument reconstruction, premise identification, inference evaluation, finding hidden assumptions, visualizing debates, Toulmin model analysis. Triggers: 'argument structure', 'premises', 'conclusion', 'inference', 'reconstruct', 'map the argument', 'Toulmin', 'argument diagram', 'validity', 'soundness', 'implicit premise', 'hidden assumption', 'logical structure'.

16 stars

Best use case

argument-mapping is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Reconstruct, visualize, and analyze argument structure. Use for: argument reconstruction, premise identification, inference evaluation, finding hidden assumptions, visualizing debates, Toulmin model analysis. Triggers: 'argument structure', 'premises', 'conclusion', 'inference', 'reconstruct', 'map the argument', 'Toulmin', 'argument diagram', 'validity', 'soundness', 'implicit premise', 'hidden assumption', 'logical structure'.

Teams using argument-mapping should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/argument-mapping/SKILL.md --create-dirs "https://raw.githubusercontent.com/diegosouzapw/awesome-omni-skill/main/skills/machine-learning/argument-mapping/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/argument-mapping/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How argument-mapping Compares

Feature / Agentargument-mappingStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Reconstruct, visualize, and analyze argument structure. Use for: argument reconstruction, premise identification, inference evaluation, finding hidden assumptions, visualizing debates, Toulmin model analysis. Triggers: 'argument structure', 'premises', 'conclusion', 'inference', 'reconstruct', 'map the argument', 'Toulmin', 'argument diagram', 'validity', 'soundness', 'implicit premise', 'hidden assumption', 'logical structure'.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Argument Mapping Skill

Master the art of reconstructing, visualizing, and evaluating the logical structure of arguments.

## Why Map Arguments?

Argument mapping serves several purposes:
1. **Clarify**: Make implicit structure explicit
2. **Evaluate**: Assess validity and soundness systematically
3. **Communicate**: Present complex arguments visually
4. **Critique**: Identify weaknesses and hidden assumptions
5. **Steelman**: Ensure fair representation of opposing views

## Basic Argument Structure

### Components of an Argument

| Component | Definition | Example |
|-----------|------------|---------|
| **Conclusion** | The claim being argued for | "Socrates is mortal" |
| **Premise** | A reason supporting the conclusion | "All men are mortal" |
| **Inference** | The logical move from premises to conclusion | "Therefore..." |
| **Assumption** | Unstated premise needed for validity | (Often hidden) |

### Simple Argument Form

```
P1: [Premise 1]
P2: [Premise 2]
-------------------
C: [Conclusion]
```

**Example**:
```
P1: All men are mortal
P2: Socrates is a man
-------------------
C: Socrates is mortal
```

## The Toulmin Model

Stephen Toulmin's model captures the nuanced structure of real-world arguments.

### Six Components

```
                        QUALIFIER
                            │
                            ▼
  GROUNDS ──────────► CLAIM ◄─────────── REBUTTAL
      │                  ▲                    │
      │                  │                    │
      ▼                  │                    ▼
  WARRANT ◄──────── BACKING               (Unless...)
```

| Component | Definition | Example |
|-----------|------------|---------|
| **Claim** | The conclusion/assertion | "We should ban smoking in restaurants" |
| **Grounds** | Evidence/data supporting claim | "Secondhand smoke causes cancer" |
| **Warrant** | Principle connecting grounds to claim | "We should prevent cancer-causing exposures" |
| **Backing** | Support for the warrant itself | "Preventing harm is a core purpose of public policy" |
| **Qualifier** | Degree of certainty | "Probably," "Certainly," "Presumably" |
| **Rebuttal** | Conditions where claim fails | "Unless economic harm outweighs health benefits" |

### Toulmin Diagram Template

```
┌─────────────────────────────────────────────────────────────────────┐
│                                                                     │
│  CLAIM: [Central thesis/conclusion]                                 │
│         Qualifier: [Certainly/Probably/Possibly]                    │
│                                                                     │
│  ────────────────────────────────────────────────────────────────   │
│                                                                     │
│  GROUNDS:                          │  REBUTTAL:                     │
│  [Evidence/facts/data]             │  Unless [exception conditions] │
│                                    │                                │
│  ────────────────────────────────────────────────────────────────   │
│                                                                     │
│  WARRANT:                                                           │
│  [Principle that licenses inference from grounds to claim]          │
│                                                                     │
│  ────────────────────────────────────────────────────────────────   │
│                                                                     │
│  BACKING:                                                           │
│  [Support for the warrant]                                          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
```

## Argument Reconstruction Protocol

### Step 1: Identify the Conclusion
What is the main claim being defended?

**Indicator words**: therefore, thus, hence, so, consequently, it follows that, we can conclude

**If not explicit**: What would the speaker want you to believe/do?

### Step 2: Find the Premises
What reasons are given for the conclusion?

**Indicator words**: because, since, for, given that, as shown by, the reason is

**List them**: Number each premise explicitly (P1, P2, P3...)

### Step 3: Make Implicit Premises Explicit
What unstated assumptions are needed for the argument to work?

**Test**: If we add this premise, does the argument become valid?

**Charity**: Choose the most reasonable implicit premises

### Step 4: Analyze the Structure
How do the premises relate?

**Linked premises**: Work together (all needed)
```
    P1 + P2
       │
       ▼
       C
```

**Convergent premises**: Independent support (each sufficient)
```
    P1     P2
     \    /
      \  /
       C
```

**Serial/Chain arguments**: One supports another
```
    P1
     │
    P2
     │
     C
```

### Step 5: Evaluate
- **Validity**: Does conclusion follow from premises?
- **Soundness**: Are premises actually true?
- **Strength** (inductive): How probable is conclusion given premises?

## Diagramming Conventions

### Standard Notation

```
┌─────┐
│ P1  │  ← Premise (box)
└──┬──┘
   │
   ▼
┌─────┐
│  C  │  ← Conclusion (box)
└─────┘
```

### Linked vs. Convergent

**Linked** (all premises needed together):
```
┌─────┐   ┌─────┐
│ P1  │───│ P2  │
└──┬──┘   └──┬──┘
   └────┬────┘
        ▼
    ┌─────┐
    │  C  │
    └─────┘
```

**Convergent** (independent support):
```
┌─────┐         ┌─────┐
│ P1  │         │ P2  │
└──┬──┘         └──┬──┘
   │             │
   └─────┬───────┘
         ▼
     ┌─────┐
     │  C  │
     └─────┘
```

### Sub-Arguments

When a premise is itself supported:
```
┌─────┐
│ P1a │  ← Sub-premise
└──┬──┘
   ▼
┌─────┐
│ P1  │  ← Intermediate conclusion / Premise for main argument
└──┬──┘
   │
┌──┴──┐
│ P2  │
└──┬──┘
   ▼
┌─────┐
│  C  │  ← Main conclusion
└─────┘
```

### Objections and Rebuttals

```
┌─────┐
│ P1  │
└──┬──┘
   ▼
┌─────┐         ┌─────────┐
│  C  │ ◄─ ✗ ───│Objection│
└─────┘         └────┬────┘
                     │
                ┌────▼────┐
                │ Rebuttal│
                └─────────┘
```

## Dialectical Tree Format

For multi-position debates:

```
THESIS: [Main Position A]
│
├── Support 1: [Argument for A]
│   ├── Evidence 1a
│   └── Evidence 1b
│
├── Support 2: [Another argument for A]
│
└── ANTITHESIS: [Opposing Position B]
    │
    ├── Objection to Support 1: [Why it fails]
    │
    ├── Objection to Support 2: [Why it fails]
    │
    └── Positive argument for B
        │
        └── SYNTHESIS: [Higher-level resolution]
            │
            ├── What's preserved from A
            ├── What's preserved from B
            └── What's new
```

## Common Argument Patterns

### Deductive Patterns

**Modus Ponens**:
```
P1: If A, then B
P2: A
---------------
C: B
```

**Modus Tollens**:
```
P1: If A, then B
P2: Not B
---------------
C: Not A
```

**Disjunctive Syllogism**:
```
P1: A or B
P2: Not A
---------------
C: B
```

**Hypothetical Syllogism**:
```
P1: If A, then B
P2: If B, then C
---------------
C: If A, then C
```

**Reductio ad Absurdum**:
```
P1: Assume A (for contradiction)
P2: A leads to contradiction B & not-B
---------------
C: Not A
```

### Inductive Patterns

**Generalization**:
```
P1: Sample S has property P
P2: Sample S is representative of population X
---------------
C: (Probably) All X have property P
```

**Analogy**:
```
P1: A has properties F, G, H
P2: B has properties F, G
P3: A has property X
---------------
C: (Probably) B has property X
```

**Inference to Best Explanation**:
```
P1: Phenomenon P is observed
P2: Hypothesis H would explain P
P3: H is the best available explanation
---------------
C: (Probably) H is true
```

### Philosophical Argument Patterns

**Conceivability Argument**:
```
P1: X is conceivable
P2: If conceivable, then possible
---------------
C: X is possible
```

**Counterexample**:
```
P1: Thesis T claims all X are Y
P2: Case C is X but not Y
---------------
C: Thesis T is false
```

**Thought Experiment**:
```
P1: In scenario S, intuition I is strong
P2: If I is correct, then principle P
---------------
C: Principle P
```

## Hidden Assumption Detection

### Method 1: Gap Analysis
1. State the premises
2. State the conclusion
3. Ask: What must be true for this inference to work?
4. The answer is the hidden assumption

### Method 2: Negation Test
1. Negate a potential assumption
2. If the argument fails, the assumption was needed

### Method 3: Charity + Validity
1. Assume the argument is intended to be valid
2. What premise would make it valid?
3. That's the most charitable hidden assumption

### Common Hidden Assumptions

| Type | Example |
|------|---------|
| **Empirical** | Facts about the world assumed without evidence |
| **Normative** | Value judgments assumed without defense |
| **Conceptual** | Definitions assumed without clarification |
| **Background** | Shared context assumed without statement |
| **Scope** | Universality assumed without justification |

## Evaluation Criteria

### For Deductive Arguments

| Criterion | Question | Assessment |
|-----------|----------|------------|
| **Validity** | Does conclusion follow necessarily? | Yes/No |
| **Soundness** | Are all premises true? | Yes/No/Unknown |
| **Completeness** | Are hidden premises stated? | Yes/Partially/No |

### For Inductive Arguments

| Criterion | Question | Assessment |
|-----------|----------|------------|
| **Strength** | How probable is conclusion given premises? | Strong/Moderate/Weak |
| **Cogency** | Are premises true AND argument strong? | Yes/No |
| **Sample quality** | Is evidence representative? | Yes/No |

## Output Templates

### Standard Reconstruction

```markdown
## Argument Reconstruction: [Topic/Source]

### Conclusion
[State the main claim being argued for]

### Explicit Premises
P1: [First stated premise]
P2: [Second stated premise]
P3: [Third stated premise]

### Hidden Premises
H1: [First unstated assumption needed for validity]
H2: [Second unstated assumption]

### Argument Structure
[Diagram showing how premises relate to conclusion]

### Evaluation
- **Validity**: [Valid/Invalid—explain]
- **Soundness**: [Sound/Unsound/Unknown—explain]
- **Key weakness**: [Most vulnerable point]

### Dialectical Context
[How this argument relates to the broader debate]
```

### Debate Map

```markdown
## Debate Map: [Topic]

### Question at Issue
[The central question being debated]

### Position A: [Label]
**Thesis**: [Main claim]

**Arguments**:
1. [Argument 1]
   - Objection: [Counter]
   - Reply: [Response]
2. [Argument 2]

### Position B: [Label]
**Thesis**: [Main claim]

**Arguments**:
1. [Argument 1]
2. [Argument 2]

### Points of Agreement
- [Shared premise 1]
- [Shared premise 2]

### Core Disagreement
[What the debate ultimately turns on]

### Assessment
[Which position is stronger and why]
```

## Integration with Other Skills

- **philosophical-analyst**: Use mapping in step 2 (argument reconstruction)
- **symposiarch**: Map arguments during debate management
- **thought-experiments**: Map the argument structure of thought experiment cases
- **devils-advocate**: Identify weak premises in argument maps

## Reference Files

- `patterns.md`: Comprehensive catalog of argument patterns
- `diagramming.md`: Extended diagramming conventions and tools

Related Skills

ai-product-strategy-mapping

16
from diegosouzapw/awesome-omni-skill

A framework to assess and integrate AI into your product strategy by mapping core customer problems to AI capabilities. Use this when your industry is facing a major technology shift, when prioritizing an AI roadmap, or when deciding between augmenting existing features vs. building new AI-first solutions.

threat-mitigation-mapping

16
from diegosouzapw/awesome-omni-skill

Map identified threats to appropriate security controls and mitigations. Use when prioritizing security investments, creating remediation plans, or validating control effectiveness.

security-scanning-threat-mitigation-mapping

16
from diegosouzapw/awesome-omni-skill

Map identified threats to appropriate security controls and mitigations. Use when prioritizing security investments, creating remediation plans, or validating control effectiveness. Use when: the task directly matches threat mitigation mapping responsibilities within plugin security-scanning. Do not use when: a more specific framework or task-focused skill is clearly a better match.

hive-mapping

16
from diegosouzapw/awesome-omni-skill

Schema mappings for auto-syncing embedded documents

ddd-context-mapping

16
from diegosouzapw/awesome-omni-skill

Map relationships between bounded contexts and define integration contracts using DDD context mapping patterns.

argument-analysis

16
from diegosouzapw/awesome-omni-skill

Analyze argument structure, identify logical gaps, suggest evidence needs, generate counterarguments, apply claim-evidence-warrant framework. Use when strengthening arguments, analyzing persuasive writing, checking logical validity, or when user asks to improve reasoning or logic.

action-mapping-designer

16
from diegosouzapw/awesome-omni-skill

This skill should be used when ensuring training focuses on performance outcomes and business impact. Use this skill to identify essential content, design performance-focused activities, create job aids, and eliminate unnecessary training.

agent-skill-mapping

16
from diegosouzapw/awesome-omni-skill

Skillの割当表(agent -> skills)を作るときのルール集。skill-assigner が mapping を更新するときに参照する。

bgo

10
from diegosouzapw/awesome-omni-skill

Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.

Coding & Development

technical-architecture

16
from diegosouzapw/awesome-omni-skill

Autonomous Staff Engineer agent that analyzes a product requirement brief, extracts non-functional requirements, and generates a comprehensive technical architecture document. Accepts an optional tech-stack-preferences.md file path. Runs end-to-end without asking questions. Use when turning product requirements into technical architecture decisions.

tdd

16
from diegosouzapw/awesome-omni-skill

Use when implementing features or fixing bugs — write the test first, watch it fail, write minimal code to pass. Ensures tests verify behavior by requiring failure first.

tag-based-search

16
from diegosouzapw/awesome-omni-skill

Code tagging system using @FEAT, @COMP, @TYPE tags for easy discovery and navigation. Use when adding documentation tags or searching for related code across the codebase.