mermaid-conventions
Conventions for creating consistent Mermaid diagrams including decision node layout, edge ordering, and flowchart direction rules.
Best use case
mermaid-conventions is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Conventions for creating consistent Mermaid diagrams including decision node layout, edge ordering, and flowchart direction rules.
Teams using mermaid-conventions 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
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/mermaid-conventions/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How mermaid-conventions Compares
| Feature / Agent | mermaid-conventions | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Conventions for creating consistent Mermaid diagrams including decision node layout, edge ordering, and flowchart direction rules.
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
# Mermaid Diagram Conventions
## Decision Node Layout (Flowcharts)
When creating mermaid flowcharts with decision nodes (`{}`), follow these rules for edge ordering:
### Rule 1: Yes/positive path goes LEFT (list first)
The first edge from a decision node renders to the left in top-down (`TD`) flowcharts. Always list the positive/affirmative/happy-path edge first.
```mermaid
%% CORRECT: Yes listed first → renders left (prominent)
flowchart TD
A{Ready?}
A -- Yes --> B[Proceed]
A -- No --> C[Wait]
```
```mermaid
%% WRONG: No listed first → renders left (confusing)
flowchart TD
A{Ready?}
A -- No --> C[Wait]
A -- Yes --> B[Proceed]
```
### Rule 2: Happy path stays in the main vertical flow
The positive/expected path should continue straight down the main trunk of the diagram. Error handling, fallbacks, and edge cases should branch off to the side.
```mermaid
%% CORRECT: Happy path flows straight down
flowchart TD
A[Start] --> B{Valid?}
B -- Yes --> C[Process]
B -- No --> D[Show error]
C --> E[Done]
```
### Rule 3: Negative/discouraging behavior appears later in hierarchy
Place blocking, error, and "don't do this" paths lower in the visual hierarchy:
- Positive outcomes are rendered first (visually prominent, left side)
- Negative outcomes are rendered second (visually subordinate, right side)
- Dead-ends and error states appear at the leaves, not near the root
### Rule 4: Edge ordering determines position
In mermaid, the order you list edges from a node controls layout:
- **First edge** → left (TD) or top (LR)
- **Second edge** → right (TD) or bottom (LR)
Use this to control which path gets visual prominence.
## Subgraph Ordering
List subgraphs in logical reading order:
1. Inputs/sources first (e.g., "Users", "Engineer Laptops")
2. Processing/infrastructure middle (e.g., "Network", "Servers")
3. Outputs/results last (e.g., "License Servers", "Results")
## Connection Styles
Use connection styles to convey meaning:
- `-->` solid arrow: active/primary connection
- `-.->` dotted arrow: blocked/inactive/secondary connection
- `-.-` dotted line (no arrow): association/relationship (not a flow)
- `---` solid line (no arrow): strong association
## PDF Rendering
When documents will be converted to PDF:
- Mermaid blocks render via mermaid.ink API as PNG images
- Keep diagrams simple enough to be readable at A4 scale
- Use `generate_pdfs.py` in the admin directory to regenerate PDFs after mermaid changes
- The script includes retry logic for mermaid.ink rate limits
## Checklist
Before committing a mermaid diagram:
- [ ] Yes/positive edges listed before No/negative edges at every decision node
- [ ] Happy path flows straight down the main trunk
- [ ] Error/blocking states branch to the side
- [ ] Subgraphs in logical reading order
- [ ] Connection styles match the relationship type
- [ ] Diagram readable at A4 print sizeRelated Skills
mkdocs-7-mermaid-diagrams
Sub-skill of mkdocs: 7. Mermaid Diagrams.
orcawave-analysis-diffractionspec-specyml-conventions
Sub-skill of orcawave-analysis: DiffractionSpec Conventions (spec.yml to OrcaWave).
marp-9-mermaid-diagrams
Sub-skill of marp: 9. Mermaid Diagrams.
memory-management-conventions
Sub-skill of memory-management: Conventions.
test-oversized-skill
A test fixture skill that exceeds 200 lines with multiple H2/H3 sections for split testing.
interactive-report-generator
Generate interactive HTML reports with Plotly visualizations from data analysis results. Supports dashboards, charts, and professional styling.
data-validation-reporter
Generate interactive validation reports with quality scoring, missing data analysis, and type checking. Combines Pandas validation, Plotly visualization, and YAML configuration for comprehensive data quality reporting.
agent-os-framework
Generate standardized .agent-os directory structure with product documentation, mission, tech-stack, roadmap, and decision records. Enables AI-native workflows.
OrcaFlex Specialist Skill
```yaml
repo-ecosystem-hygiene
Interpret the daily read-only repo ecosystem hygiene audit and route remediation through approved workflows.
domain-knowledge-sweep
Systematic multi-source research of an engineering domain. Spawns parent issue → 6 research subissues (Standards, Academic, Industry, LinkedIn-marketing, Code-audit, Synthesis) → gap implementation subissues. Replaces LinkedIn-only extraction with defensible comprehensive sourcing.
subagent-write-verification
Independently verify subagent-claimed file writes with filesystem and git checks before treating the artifact as real, before committing it, and before referencing the path in downstream prompts.