home / skills / nealcaren / social-data-analysis / dag-development

dag-development skill

safe

/plugins/dag-development/skills/dag-development

This skill helps translate research questions into publication-ready DAGs and render them with Mermaid, R, or Python for clear causal diagrams.

npx playbooks add skill nealcaren/social-data-analysis --skill dag-development

Review the files below or copy the command above to add this skill to your agents.

Files (13)

SKILL.md

3.6 KB

---
name: dag-development
description: Develop causal diagrams (DAGs) from social-science research questions and literature, then render publication-ready figures using Mermaid, R, or Python.
---

# DAG Development

You help users **develop causal diagrams (DAGs)** from their research questions, theory, or core paper, and then render them as clean, publication-ready figures using **Mermaid**, **R (ggdag)**, or **Python (networkx)**. This skill spans **conceptual translation** and **technical rendering**.

## When to Use This Skill

Use this skill when users want to:
- Translate a research question or paper into a DAG
- Clarify mechanisms, confounders, and selection/measurement structures
- Turn a DAG into a figure for papers or slides
- Choose a rendering stack (Mermaid vs R vs Python)
- Export SVG/PNG/PDF consistently

## Core Principles

1.  **Explicit assumptions**: DAGs encode causal claims; make assumptions visible.
2.  **Rigorous Identification**: Use the 6-step algorithm and d-separation to validate the DAG structure *before* rendering.
3.  **Reproducible by default**: Provide text-based inputs and scripted outputs.
4.  **Exportable assets**: Produce SVG/PNG (and PDF where possible).
5.  **Tool choice**: Offer three rendering paths with tradeoffs.
6.  **Minimal styling**: Keep figures simple and journal‑friendly.

## Workflow Phases

### Phase 0: Theory → DAG Translation
**Goal**: Help users turn their current thinking or a core paper into a **DAG Blueprint**.
- Clarify the causal question and unit of analysis
- Translate narratives/mechanisms into nodes and edges
- Record assumptions and uncertain edges

**Guide**: `phases/phase0-theory.md`
**Concepts**: `confounding.md`, `potential_outcomes.md`

> **Pause**: Confirm the DAG blueprint before auditing.

---

### Phase 1: Critique & Identification
**Goal**: **Validate** the DAG blueprint using formal rules (Shrier & Platt, Greenland).
- Run the **6-step algorithm** (Check descendants, non-ancestors).
- Check for **Collider-Stratification Bias**.
- Identify the **Sufficient Adjustment Set**.
- Detect threats from unobserved variables.

**Guide**: `phases/phase1-identification.md`
**Concepts**: `six_step_algorithm.md`, `d_separation.md`, `colliders.md`, `selection_bias.md`

> **Pause**: Confirm the "Validated DAG" (nodes + edges + adjustment strategy) before formatting.

---

### Phase 2: Inputs & Format
**Goal**: Turn the Validated DAG into render‑ready inputs.
- Finalize node list, edge list, and node types (Exposure, Outcome, Latent, Selection).
- Choose output formats (SVG/PNG/PDF) and layout.

**Guide**: `phases/phase2-inputs.md`

> **Pause**: Confirm the DAG inputs and output target before rendering.

---

### Phase 3: Mermaid Rendering
**Goal**: Render a DAG quickly from Markdown using Mermaid CLI.

**Guide**: `phases/phase3-mermaid.md`

> **Pause**: Confirm Mermaid output or move to R/Python.

---

### Phase 4: R Rendering (ggdag)
**Goal**: Render a DAG using R with ggdag for publication‑quality plots.

**Guide**: `phases/phase4-r.md`

> **Pause**: Confirm R output or move to Python.

---

### Phase 5: Python Rendering (networkx)
**Goal**: Render a DAG using Python with `uv` inline dependencies.

**Guide**: `phases/phase5-python.md`

---

## Output Expectations

Provide:
- A **DAG Blueprint** (Phase 0)
- An **Identification Memo** (Phase 1)
- A **DAG source file** (Mermaid `.mmd`, R `.R`, or Python `.py`)
- **Rendered figure(s)** in SVG/PNG (and PDF when available)

## Invoking Phase Agents

Use the Task tool for each phase:

```
Task: Phase 3 Mermaid
subagent_type: general-purpose
model: sonnet
prompt: Read phases/phase3-mermaid.md and render the user’s DAG
```

Overview

This skill helps you develop causal diagrams (DAGs) from social‑science research questions and literature, then render publication‑ready figures using Mermaid, R (ggdag), or Python (networkx). I translate theory and papers into explicit DAG blueprints, validate identification, and produce reproducible source files and exportable figures (SVG/PNG/PDF).

How this skill works

I guide you through four core phases: translate theory into a DAG blueprint, validate the DAG with formal identification checks (6‑step algorithm and d‑separation), convert the validated DAG into render‑ready inputs, and produce figures using Mermaid, R, or Python. At each phase you confirm the blueprint, validation memo, and rendering choices so outputs remain reproducible and journal‑friendly.

When to use it

You need to turn a research question or article narrative into an explicit causal DAG.
You want to identify confounders, colliders, mediators, or selection structures before analysis.
You need a publication‑quality DAG figure for a paper, presentation, or preprint.
You want reproducible, scriptable DAG source files (Mermaid, R, Python) and exports (SVG/PNG/PDF).
You’re deciding among rendering stacks and need tradeoff guidance (speed vs styling vs reproducibility).

Best practices

Start by clearly stating the causal question and unit of analysis; record every assumption explicitly.
Validate the DAG with the 6‑step identification algorithm and d‑separation before any rendering.
Classify node types (exposure, outcome, latent, selection) and annotate uncertain edges for review.
Prefer minimal, journal‑friendly styling; keep figures simple and legible at publication size.
Produce scriptable source files and export assets so figures are reproducible and versionable.

Example use cases

Convert a qualitative theory section or core paper into a formal DAG blueprint and adjustment memo.
Detect collider‑stratification or selection bias risks and derive a sufficient adjustment set.
Create quick proof‑of‑concept DAGs with Mermaid Markdown for slides and then refine in R for publication.
Export SVG/PNG/PDF figures from R (ggdag) or Python (networkx) with reproducible code for replication archives.
Generate DAG source files and an identification memo to include as supplementary material for a manuscript.

FAQ

Which rendering stack should I pick?

Use Mermaid for fast markdown‑driven diagrams, R (ggdag) for publication styling and statistical integration, and Python (networkx) for programmatic control and complex layouts.

Can you show unobserved (latent) variables and selection nodes?

Yes — I annotate node types (latent, selection) and incorporate them into the identification check and final figure exports.