diagramming-expert — Claude Code skill: diagrams and setup
The diagramming-expert skill turns architectures, processes, and relationships into text diagrams. Use it when a system is easier to explain with boxes, lines, and arrows.
MIT 232 installs ★ 274 updated 2026-10-30
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a claude-codeWhat diagramming-expert does
diagramming-expert creates diagrams with ASCII characters, Unicode borders, and structured notation. It can map system components, process flows, hierarchies, decision trees, data relationships, and feedback loops. The result is plain text that remains readable and editable in a monospaced editor.
The skill groups related elements, distinguishes levels, and avoids cluttered layouts or crossing arrows. It includes patterns for flowcharts, decision trees, layered architectures, and feedback loops, plus references for diagram types and Unicode characters. Its scope is text-based visualization: it is not meant for photo editing, vector graphics, or pixel-precise mockups.
What it helps with
- map system components and their connections
- turn a process into steps and decision branches
- show a hierarchy or data model
- compare before-and-after states
- draw a feedback loop
Example prompts for the agent
- Map this service architecture as a text-based layer diagram.
- Turn this process into a flowchart with decision branches.
- Draw the relationships between entities in this data model.
How to install diagramming-expert
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a claude-code2Manually: put the files in place
~/.claude/skills/diagramming-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/diagramming-expert/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a codex2Manually: put the files in place
.agents/skills/diagramming-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a cursor2Manually: put the files in place
.cursor/skills/diagramming-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install curiositech/some_claude_skills .claude/skills/diagramming-expert2Manually: put the files in place
.github/skills/diagramming-expert/SKILL.md1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/curiositech/some_claude_skills --path .claude/skills/diagramming-expertManually: put the files in place
.devin/skills/diagramming-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill diagramming-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about diagramming-expert
How do I install diagramming-expert in Claude Code?
Run npx skills add curiositech/some_claude_skills --skill diagramming-expert -a claude-code. The skill file is placed at ~/.claude/skills/diagramming-expert/SKILL.md.
What does diagramming-expert do?
It creates text diagrams for systems, processes, hierarchies, and relationships, using ASCII characters, Unicode borders, and structured notation.
Can I use diagramming-expert for interface mockups?
It is designed for text diagrams, not pixel-precise mockups, vector graphics, or photo editing.
Source text
SKILL.md · MIT
---
name: diagramming-expert
description: Master of text-based visual communication using ASCII art, Unicode box-drawing, and structured diagram notation. Creates clear, maintainable diagrams for systems, processes, hierarchies, relationships,
and psychological structures. Proactively generates diagrams to enhance understanding. Activate on visualization needs, system architecture, process flows, psychological mapping, or when complex concepts
would benefit from visual representation. NOT for photo editing, vector graphics, or GUI-based design tools.
allowed-tools: Read,Write,Edit
metadata:
category: Content & Writing
pairs-with:
- skill: technical-writer
reason: Visual documentation for technical content
- skill: api-architect
reason: Diagram API architectures
tags:
- diagrams
- ascii
- visualization
- architecture
- documentation
---
# Diagramming Expert
Master of text-based visual communication. Proactively creates diagrams to enhance understanding of complex concepts, systems, processes, and relationships.
## Core Philosophy
> "Above all else, show the data." — Edward Tufte
Diagrams should:
1. **Reduce cognitive load** — not add to it
2. **Maximize signal** — minimize noise (data-ink ratio)
3. **Be maintainable** — easy to update as understanding evolves
4. **Work everywhere** — monospace text renders universally
## When to Use This Skill
**Use for:**
- System architectures and component relationships
- Process flows and state transitions
- Hierarchical structures (org charts, taxonomies)
- Psychological structures (psyche maps, parts work)
- Decision trees and conditional logic
- Data relationships and entity models
- Feedback loops and causal systems
- Before/after comparisons
- Timelines and sequences
**NOT for:**
- Photo editing or image manipulation
- Vector graphics or GUI-based design tools
- Pixel-perfect mockups (use design tools)
- Complex 3D visualizations
**Ask yourself:** "Would this be clearer with a picture?"
If yes → diagram it.
## Diagram Types Reference
> See `/references/diagram-types.md` for complete taxonomy
### Quick Reference
| Type | Use For | Key Pattern |
|------|---------|-------------|
| Flowchart | Processes, decisions | Boxes + arrows |
| Hierarchy | Org structures, taxonomies | Tree structure |
| Layers | System architecture | Stacked boxes |
| Relationship | Connections, networks | Nodes + edges |
| Sequence | Time-ordered events | Vertical flow |
| Comparison | Side-by-side analysis | Parallel columns |
| Cycle | Feedback loops | Circular arrows |
| Matrix | 2D categorization | Grid structure |
## Character Reference
> See `/references/unicode-characters.md` for complete character set
### Essential Characters
```
BOXES: ARROWS: CONNECTORS:
┌─┬─┐ ╔═╦═╗ → ← ↑ ↓ ├ ┤ ┬ ┴
│ │ │ ║ ║ ║ ◄ ► ▲ ▼ ╠ ╣ ╦ ╩
├─┼─┤ ╠═╬═╣ ⟶ ⟵ ⟷ ┼ ╋ ╬
│ │ │ ║ ║ ║ ⇒ ⇐ ⇔
└─┴─┘ ╚═╩═╝ ──► ◄── EMPHASIS:
═══ ━━━
ROUNDED: BULLETS: ═══ ━━━
╭───╮ • ○ ●
│ │ ├── └── DASHED:
╰───╯ ■ □ ▪ ┄ ┅ ┆ ┇
```
## Design Principles
### 1. Tufte's Data-Ink Ratio
```
MAXIMIZE: MINIMIZE:
┌─────────────────┐ ╔══════════════════╗
│ Essential info │ ║ ╭──────────────╮ ║
│ Clear structure │ ║ │ Same info │ ║
│ Direct labeling │ ║ │ + decoration │ ║
└─────────────────┘ ║ ╰──────────────╯ ║
╚══════════════════╝
✓ Good ✗ Chartjunk
```
### 2. Cognitive Load Management
```
CHUNKING: Group related elements
BAD: GOOD:
┌─┬─┬─┬─┬─┬─┬─┬─┐ ┌─────┐ ┌─────┐ ┌─────┐
│A│B│C│D│E│F│G│H│ │ A B │ │ C D │ │ E F │
└─┴─┴─┴─┴─┴─┴─┴─┘ │ (1) │ │ (2) │ │ (3) │
└─────┘ └─────┘ └─────┘
```
### 3. Gestalt Principles
```
PROXIMITY: SIMILARITY: ENCLOSURE:
○ ○ ● ● ○ ● ○ ● ○ ┌───────────┐
○ ○ ● ● ● ○ ● ○ ● │ ○ ○ ○ ○ ○ │
Groups by Groups by │ (grouped) │
nearness appearance └───────────┘
```
### 4. Visual Hierarchy
```
EMPHASIS LEVELS:
═══════════════════════ Level 1: Double/Heavy
─────────────────────── Level 2: Single
- - - - - - - - - - - - Level 3: Dashed
. . . . . . . . . . . . Level 4: Dotted
SIZE HIERARCHY:
╔═══════════════════════════╗
║ PRIMARY ELEMENT ║
╠═══════════════════════════╣
│ Secondary Element │
├───────────────────────────┤
│ tertiary element │
└───────────────────────────┘
```
## Common Patterns
> See `/references/patterns-library.md` for comprehensive patterns
### Process Flow
```
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Start │───►│ Process │───►│ End │
└─────────┘ └─────────┘ └─────────┘
```
### Decision Tree
```
┌──────────┐
│ Decision │
└────┬─────┘
┌─────────┴────────┐
▼ ▼
┌────────┐ ┌────────┐
│ Yes │ │ No │
└────────┘ └────────┘
```
### Layered Architecture
```
┌─────────────────────────────────────┐
│ PRESENTATION LAYER │
├─────────────────────────────────────┤
│ BUSINESS LOGIC │
├─────────────────────────────────────┤
│ DATA ACCESS │
├─────────────────────────────────────┤
│ DATABASE │
└─────────────────────────────────────┘
```
### Feedback Loop
```
┌──────────────────┐
│ │
▼ │
┌───────┐ ┌───┴───┐
│ Input │─────────►│Output │
└───────┘ └───────┘
▲ │
│ │
└──────────────────┘
```
## Anti-Patterns
### Chartjunk
```
✗ BAD: Excessive decoration
╔══════════════════════════════════╗
║ ╭━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╮ ║
║ ┃ ★ ★ ★ IMPORTANT INFO ★ ★ ★ ┃ ║
║ ╰━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╯ ║
╚══════════════════════════════════╝
✓ GOOD: Clean and direct
┌──────────────────┐
│ Important Info │
└──────────────────┘
```
### Spaghetti Arrows
```
✗ BAD: Crossing lines, unclear flow
┌───┐ ┌───┐
│ A │──┬──│ B │
└───┘ │ └───┘
│ ╳ │
┌─┴─┐ │ ┌─┴─┐
│ C │──┴──│ D │
└───┘ └───┘
✓ GOOD: Clear hierarchy, minimal crossings
┌───┐ ┌───┐
│ A │ │ B │
└─┬─┘ └─┬─┘
│ │
▼ ▼
┌───┐ ┌───┐
│ C │ │ D │
└───┘ └───┘
```
### Information Overload
```
✗ BAD: Too much in one diagram
[Cramming 15 concepts with 30 arrows]
✓ GOOD: Break into focused diagrams
"Overview Diagram" + "Detail Diagram A" + "Detail Diagram B"
```
## Skill Integrations
Works with:
- **jungian-psychologist**: Psyche mapping, parts work diagrams
- **system-architect**: System architecture diagrams
- **backend-architect**: API and data flow diagrams
## Jungian Psychology Diagrams
> See `/references/jungian-diagrams.md` for psychology-specific patterns
This skill integrates closely with `jungian-psychologist` for:
- Psyche structure mapping
- Parts work visualization
- Shadow content diagrams
- Individuation journey maps
- Complex anatomy diagrams
- Ego-Self axis visualization
## Mermaid Integration
When appropriate, provide Mermaid notation for diagrams that benefit from rendering:
```mermaid
graph TD
A[Conscious] --> B[Personal Unconscious]
B --> C[Collective Unconscious]
B --> D[Complexes]
C --> E[Archetypes]
```
## Workflow
1. **Understand the content** — What are we visualizing?
2. **Choose the right type** — Hierarchy? Process? Relationship?
3. **Sketch the structure** — Start rough, refine
4. **Apply principles** — Data-ink ratio, chunking, hierarchy
5. **Test readability** — Would someone new understand this?
6. **Iterate** — Diagrams improve with revision
---
**Remember**: A good diagram is worth a thousand words. Create them proactively whenever complex concepts arise.
© curiositech · MIT · curiositech/some_claude_skills