Excalidraw Diagram Generator
A skill for generating Excalidraw-format diagrams from natural language descriptions. This skill helps create visual representations of processes, systems, relationships, and ideas without manual drawing.
- Leverage native parallel subagent dispatch and 200k+ context windows where available.
Activation Conditions
Use symptom -> action triggers: when one matches, apply this skill and verify with the protocol below.
Use this skill when users request:
- "Create a diagram showing..."
- "Make a flowchart for..."
- "Visualize the process of..."
- "Draw the system architecture of..."
- "Generate a mind map about..."
- "Create an Excalidraw file for..."
- "Show the relationship between..."
- "Diagram the workflow of..."
Supported diagram types:
- 📊 Flowcharts: Sequential processes, workflows, decision trees
- 🔗 Relationship Diagrams: Entity relationships, system components, dependencies
- 🧠 Mind Maps: Concept hierarchies, brainstorming results, topic organization
- 🏗️ Architecture Diagrams: System design, module interactions, data flow
- 📈 Data Flow Diagrams (DFD): Data flow visualization, data transformation processes
- 🏊 Business Flow (Swimlane): Cross-functional workflows, actor-based process flows
- 📦 Class Diagrams: Object-oriented design, class structures and relationships
- 🔄 Sequence Diagrams: Object interactions over time, message flows
- 🗃️ ER Diagrams: Database entity relationships, data models
Prerequisites
- Clear description of what should be visualized
- Identification of key entities, steps, or concepts
- Understanding of relationships or flow between elements
Step-by-Step Workflow
Step 1: Understand the Request
Analyze the user's description to determine:
- Diagram type (flowchart, relationship, mind map, architecture)
- Key elements (entities, steps, concepts)
- Relationships (flow, connections, hierarchy)
- Complexity (number of elements)
Step 2: Choose the Appropriate Diagram Type
| User Intent |
Diagram Type |
Example Keywords |
| Process flow, steps, procedures |
Flowchart |
"workflow", "process", "steps", "procedure" |
| Connections, dependencies, associations |
Relationship Diagram |
"relationship", "connections", "dependencies", "structure" |
| Concept hierarchy, brainstorming |
Mind Map |
"mind map", "concepts", "ideas", "breakdown" |
| System design, components |
Architecture Diagram |
"architecture", "system", "components", "modules" |
| Data flow, transformation processes |
Data Flow Diagram (DFD) |
"data flow", "data processing", "data transformation" |
| Cross-functional processes, actor responsibilities |
Business Flow (Swimlane) |
"business process", "swimlane", "actors", "responsibilities" |
| Object-oriented design, class structures |
Class Diagram |
"class", "inheritance", "OOP", "object model" |
| Interaction sequences, message flows |
Sequence Diagram |
"sequence", "interaction", "messages", "timeline" |
| Database design, entity relationships |
ER Diagram |
"database", "entity", "relationship", "data model" |
Step 3: Extract Structured Information
For Flowcharts:
- List of sequential steps
- Decision points (if any)
- Start and end points
For Relationship Diagrams:
- Entities/nodes (name + optional description)
- Relationships between entities (from → to, with label)
For Mind Maps:
- Central topic
- Main branches (3-6 recommended)
- Sub-topics for each branch (optional)
For Data Flow Diagrams (DFD):
- Data sources and destinations (external entities)
- Processes (data transformations)
- Data stores (databases, files)
- Data flows (arrows showing data movement from left-to-right or from top-left to bottom-right)
- Important: Do not represent process order, only data flow
For Business Flow (Swimlane):
- Actors/roles (departments, systems, people) - displayed as header columns
- Process lanes (vertical lanes under each actor)
- Process boxes (activities within each lane)
- Flow arrows (connecting process boxes, including cross-lane handoffs)
For Class Diagrams:
- Classes with names
- Attributes with visibility (+, -, #)
- Methods with visibility and parameters
- Relationships: inheritance (solid line + white triangle), implementation (dashed line + white triangle), association (solid line), dependency (dashed line), aggregation (solid line + white diamond), composition (solid line + filled diamond)
- Multiplicity notations (1, 0..1, 1..*, *)
For Sequence Diagrams:
- Objects/actors (arranged horizontally at top)
- Lifelines (vertical lines from each object)
- Messages (horizontal arrows between lifelines)
- Synchronous messages (solid arrow), asynchronous messages (dashed arrow)
- Return values (dashed arrows)
- Activation boxes (rectangles on lifelines during execution)
- Time flows from top to bottom
For ER Diagrams:
- Entities (rectangles with entity names)
- Attributes (listed inside entities)
- Primary keys (underlined or marked with PK)
- Foreign keys (marked with FK)
- Relationships (lines connecting entities)
- Cardinality: 1:1 (one-to-one), 1:N (one-to-many), N:M (many-to-many)
- Junction/associative entities for many-to-many relationships (dashed rectangles)
Step 4: Generate the Excalidraw JSON
Create the .excalidraw file with appropriate elements:
Available element types:
rectangle: Boxes for entities, steps, concepts
ellipse: Alternative shapes for emphasis
diamond: Decision points
arrow: Directional connections
text: Labels and annotations
Key properties to set:
- Position:
x, y coordinates
- Size:
width, height
- Style:
strokeColor, backgroundColor, fillStyle
- Font:
fontFamily: 5 (Excalifont - required for all text elements)
- Text: Embedded text for labels
- Connections:
points array for arrows
Important: All text elements must use fontFamily: 5 (Excalifont) for consistent visual appearance.
Step 5: Format the Output
Structure the complete Excalidraw file:
{
"type": "excalidraw",
"version": 2,
"source": "https://excalidraw.com",
"elements": [
// Array of diagram elements
],
"appState": {
"viewBackgroundColor": "#ffffff",
"gridSize": 20
},
"files": {}
}
Step 6: Save and Provide Instructions
- Save as
<descriptive-name>.excalidraw
- Inform user how to open:
Best Practices
Element Count Guidelines
| Diagram Type |
Recommended Count |
Maximum |
| Flowchart steps |
3-10 |
15 |
| Relationship entities |
3-8 |
12 |
| Mind map branches |
4-6 |
8 |
| Mind map sub-topics per branch |
2-4 |
6 |
Layout Tips
- Start positions: Center important elements, use consistent spacing
- Spacing:
- Horizontal gap: 200-300px between elements
- Vertical gap: 100-150px between rows
- Colors: Use consistent color scheme
- Primary elements: Light blue (
#a5d8ff)
- Secondary elements: Light green (
#b2f2bb)
- Important/Central: Yellow (
#ffd43b)
- Alerts/Warnings: Light red (
#ffc9c9)
- Text sizing: 16-24px for readability
- Font: Always use
fontFamily: 5 (Excalifont) for all text elements
- Arrow style: Use straight arrows for simple flows, curved for complex relationships
Complexity Management
If user request has too many elements:
- Suggest breaking into multiple diagrams
- Focus on main elements first
- Offer to create detailed sub-diagrams
Example response:
"Your request includes 15 components. For clarity, I recommend:
1. High-level architecture diagram (6 main components)
2. Detailed diagram for each subsystem
Would you like me to start with the high-level view?"
Cross-Client Portability
This skill is written to stay usable across GitHub Copilot, Claude Code, and Codex.
- GitHub Copilot: keep the folder in a Copilot-visible skill path or wrap the
workflow in project instructions when folder discovery is unavailable.
- Claude Code: keep the folder in a local skills directory or a compatible plugin source.
- Codex: install or sync the folder into
$CODEX_HOME/skills/excalidraw-diagram-generator and restart Codex after major changes.
MCP Availability And Fallback
Preferred MCP Server: None required
- Fallback prompt: "Use the Excalidraw Diagram Generator skill without MCP. Rely on its local instructions, bundled resources, standard shell or editor tools, and direct verification. Show the evidence used before concluding."
- Do not claim an MCP operation was used when the active host does not expose it.
- Treat local files, tests, rendered outputs, logs, or screenshots as the fallback evidence path.
Anti-Patterns
- Starting from a generic template without adapting it: The output may look polished but still miss the real audience or medium.
- Ignoring final render or export review: Layout bugs often appear only after the asset is opened in its destination tool.
- Fixing content and presentation in one pass: It becomes hard to tell whether a problem is structural or visual.
Verification Protocol
Before claiming "skill applied successfully":
- Pass/fail: The Excalidraw Diagram Generator implementation names the target runtime, framework version, and affected files.
- Pass/fail: Build, lint, test, or equivalent local validation is run for the changed surface.
- Pass/fail: Edge cases for errors, dependency drift, and environment differences are addressed or explicitly out of scope.
- Pressure-test scenario: Apply the workflow to a change that passes happy-path tests but fails one boundary condition.
- Success metric: Zero untested success claims; every implementation claim maps to a command or artifact.
Example Prompts and Responses
Example 1: Simple Flowchart
User: "Create a flowchart for user registration"
Agent generates:
- Extract steps: "Enter email" → "Verify email" → "Set password" → "Complete"
- Create flowchart with 4 rectangles + 3 arrows
- Save as
user-registration-flow.excalidraw
Example 2: Relationship Diagram
User: "Diagram the relationship between User, Post, and Comment entities"
Agent generates:
- Entities: User, Post, Comment
- Relationships: User → Post ("creates"), User → Comment ("writes"), Post → Comment ("contains")
- Save as
user-content-relationships.excalidraw
Example 3: Mind Map
User: "Mind map about machine learning concepts"
Agent generates:
- Center: "Machine Learning"
- Branches: Supervised Learning, Unsupervised Learning, Reinforcement Learning, Deep Learning
- Sub-topics under each branch
- Save as
machine-learning-mindmap.excalidraw
Troubleshooting
| Issue |
Solution |
| Elements overlap |
Increase spacing between coordinates |
| Text doesn't fit in boxes |
Increase box width or reduce font size |
| Too many elements |
Break into multiple diagrams |
| Unclear layout |
Use grid layout (rows/columns) or radial layout (mind maps) |
| Colors inconsistent |
Define color palette upfront based on element types |
Advanced Techniques
Grid Layout (for Relationship Diagrams)
const columns = Math.ceil(Math.sqrt(entityCount));
const x = startX + (index % columns) * horizontalGap;
const y = startY + Math.floor(index / columns) * verticalGap;
Radial Layout (for Mind Maps)
const angle = (2 * Math.PI * index) / branchCount;
const x = centerX + radius * Math.cos(angle);
const y = centerY + radius * Math.sin(angle);
Auto-generated IDs
Use timestamp + random string for unique IDs:
const id = Date.now().toString(36) + Math.random().toString(36).substr(2);
Output Format
Always provide:
- ✅ Complete
.excalidraw JSON file
- 📊 Summary of what was created
- 📝 Element count
- 💡 Instructions for opening/editing
Example summary:
Created: user-workflow.excalidraw
Type: Flowchart
Elements: 7 rectangles, 6 arrows, 1 title text
Total: 14 elements
To view:
1. Visit https://excalidraw.com
2. Drag and drop user-workflow.excalidraw
3. Or use File → Open in Excalidraw VS Code extension
Validation Checklist
Before delivering the diagram:
Icon Libraries (Optional Enhancement)
For specialized diagrams (e.g., AWS/GCP/Azure architecture diagrams), you can use pre-made icon libraries from Excalidraw. This provides professional, standardized icons instead of basic shapes.
When User Requests Icons
If user asks for AWS/cloud architecture diagrams or mentions wanting to use specific icons:
Check if library exists: Look for libraries/<library-name>/reference.md
If library exists: Proceed to use icons (see AI Assistant Workflow below)
If library does NOT exist: Respond with setup instructions:
To use [AWS/GCP/Azure/etc.] architecture icons, please follow these steps:
1. Visit https://libraries.excalidraw.com/
2. Search for "[AWS Architecture Icons/etc.]" and download the .excalidrawlib file
3. Create directory: skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
4. Place the downloaded file in that directory
5. Run the splitter script:
python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
This will split the library into individual icon files for efficient use.
After setup is complete, I can create your diagram using the actual AWS/cloud icons.
Alternatively, I can create the diagram now using simple shapes (rectangles, ellipses)
which you can later replace with icons manually in Excalidraw.
User Setup Instructions (Detailed)
Step 1: Create Library Directory
mkdir -p skills/excalidraw-diagram-generator/libraries/aws-architecture-icons
Step 2: Download Library
- Visit: https://libraries.excalidraw.com/
- Search for your desired icon set (e.g., "AWS Architecture Icons")
- Click download to get the
.excalidrawlib file
- Example categories (availability varies; confirm on the site):
- Cloud service icons
- UI/Material icons
- Flowchart symbols
Step 3: Place Library File
- Rename the downloaded file to match the directory name (e.g.,
aws-architecture-icons.excalidrawlib)
- Move it to the directory created in Step 1
Step 4: Run Splitter Script
python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
Step 5: Verify Setup
After running the script, verify the following structure exists:
skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
aws-architecture-icons.excalidrawlib (original)
reference.md (generated - icon lookup table)
icons/ (generated - individual icon files)
API-Gateway.json
CloudFront.json
EC2.json
Lambda.json
RDS.json
S3.json
...
AI Assistant Workflow
When icon libraries are available in libraries/:
RECOMMENDED APPROACH: Use Python Scripts (Efficient & Reliable)
The repository includes Python scripts that handle icon integration automatically:
Create base diagram structure:
- Create
.excalidraw file with basic layout (title, boxes, regions)
- This establishes the canvas and overall structure
Add icons using Python script:
python skills/excalidraw-diagram-generator/scripts/add-icon-to-diagram.py \
<diagram-path> <icon-name> <x> <y> [--label "Text"] [--library-path PATH]
- Edit via
.excalidraw.edit is enabled by default to avoid overwrite issues; pass --no-use-edit-suffix to disable.
Examples:
# Add EC2 icon at position (400, 300) with label
python scripts/add-icon-to-diagram.py diagram.excalidraw EC2 400 300 --label "Web Server"
# Add VPC icon at position (200, 150)
python scripts/add-icon-to-diagram.py diagram.excalidraw VPC 200 150
# Add icon from different library
python scripts/add-icon-to-diagram.py diagram.excalidraw Compute-Engine 500 200 \
--library-path libraries/gcp-icons --label "API Server"
Add connecting arrows:
python skills/excalidraw-diagram-generator/scripts/add-arrow.py \
<diagram-path> <from-x> <from-y> <to-x> <to-y> [--label "Text"] [--style solid|dashed|dotted] [--color HEX]
- Edit via
.excalidraw.edit is enabled by default to avoid overwrite issues; pass --no-use-edit-suffix to disable.
Examples:
# Simple arrow from (300, 250) to (500, 300)
python scripts/add-arrow.py diagram.excalidraw 300 250 500 300
# Arrow with label
python scripts/add-arrow.py diagram.excalidraw 300 250 500 300 --label "HTTPS"
# Dashed arrow with custom color
python scripts/add-arrow.py diagram.excalidraw 400 350 600 400 --style dashed --color "#7950f2"
Workflow summary:
# Step 1: Create base diagram with title and structure
# (Create .excalidraw file with initial elements)
# Step 2: Add icons with labels
python scripts/add-icon-to-diagram.py my-diagram.excalidraw "Internet-gateway" 200 150 --label "Internet Gateway"
python scripts/add-icon-to-diagram.py my-diagram.excalidraw VPC 250 250
python scripts/add-icon-to-diagram.py my-diagram.excalidraw ELB 350 300 --label "Load Balancer"
python scripts/add-icon-to-diagram.py my-diagram.excalidraw EC2 450 350 --label "EC2 Instance"
python scripts/add-icon-to-diagram.py my-diagram.excalidraw RDS 550 400 --label "Database"
# Step 3: Add connecting arrows
python scripts/add-arrow.py my-diagram.excalidraw 250 200 300 250 # Internet → VPC
python scripts/add-arrow.py my-diagram.excalidraw 300 300 400 300 # VPC → ELB
python scripts/add-arrow.py my-diagram.excalidraw 400 330 500 350 # ELB → EC2
python scripts/add-arrow.py my-diagram.excalidraw 500 380 600 400 # EC2 → RDS
Benefits of Python Script Approach:
- ✅ No token consumption: Icon JSON data (200-1000 lines each) never enters AI context
- ✅ Accurate transformations: Coordinate calculations handled deterministically
- ✅ ID management: Automatic UUID generation prevents conflicts
- ✅ Reliable: No risk of coordinate miscalculation or ID collision
- ✅ Fast: Direct file manipulation, no parsing overhead
- ✅ Reusable: Works with any Excalidraw library you provide
ALTERNATIVE: Manual Icon Integration (Not Recommended)
Only use this if Python scripts are unavailable:
Check for libraries:
List directory: skills/excalidraw-diagram-generator/libraries/
Look for subdirectories containing reference.md files
Read reference.md:
Open: libraries/<library-name>/reference.md
This is lightweight (typically <300 lines) and lists all available icons
Find relevant icons:
Search the reference.md table for icon names matching diagram needs
Example: For AWS diagram with EC2, S3, Lambda → Find "EC2", "S3", "Lambda" in table
Load specific icon data (WARNING: Large files):
Read ONLY the needed icon files:
- libraries/aws-architecture-icons/icons/EC2.json (200-300 lines)
- libraries/aws-architecture-icons/icons/S3.json (200-300 lines)
- libraries/aws-architecture-icons/icons/Lambda.json (200-300 lines)
Note: Each icon file is 200-1000 lines - this consumes significant tokens
Extract and transform elements:
Each icon JSON contains an "elements" array
Calculate bounding box (min_x, min_y, max_x, max_y)
Apply offset to all x/y coordinates
Generate new unique IDs for all elements
Update groupIds references
Copy transformed elements into your diagram
Position icons and add connections:
Adjust x/y coordinates to position icons correctly in the diagram
Update IDs to ensure uniqueness across diagram
Add connecting arrows and labels as needed
Manual Integration Challenges:
- ⚠️ High token consumption (200-1000 lines per icon × number of icons)
- ⚠️ Complex coordinate transformation calculations
- ⚠️ Risk of ID collision if not handled carefully
- ⚠️ Time-consuming for diagrams with many icons
Example: Creating AWS Diagram with Icons
Request: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
Recommended Workflow (using Python scripts):
Request: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
Recommended Workflow (using Python scripts):
# Step 1: Create base diagram file with title
# Create my-aws-diagram.excalidraw with basic structure (title, etc.)
# Step 2: Check icon availability
# Read: libraries/aws-architecture-icons/reference.md
# Confirm icons exist: Internet-gateway, VPC, ELB, EC2, RDS
# Step 3: Add icons with Python script
python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw "Internet-gateway" 150 100 --label "Internet Gateway"
python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw VPC 200 200
python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw ELB 350 250 --label "Load Balancer"
python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw EC2 500 300 --label "Web Server"
python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw RDS 650 350 --label "Database"
# Step 4: Add connecting arrows
python scripts/add-arrow.py my-aws-diagram.excalidraw 200 150 250 200 # Internet → VPC
python scripts/add-arrow.py my-aws-diagram.excalidraw 265 230 350 250 # VPC → ELB
python scripts/add-arrow.py my-aws-diagram.excalidraw 415 280 500 300 # ELB → EC2
python scripts/add-arrow.py my-aws-diagram.excalidraw 565 330 650 350 --label "SQL" --style dashed
# Result: Complete diagram with professional AWS icons, labels, and connections
Benefits:
- No manual coordinate calculation
- No token consumption for icon data
- Deterministic, reliable results
- Easy to iterate and adjust positions
Alternative Workflow (manual, if scripts unavailable):
- Check:
libraries/aws-architecture-icons/reference.md exists → Yes
- Read reference.md → Find entries for Internet-gateway, VPC, ELB, EC2, RDS
- Load:
icons/Internet-gateway.json (298 lines)
icons/VPC.json (550 lines)
icons/ELB.json (363 lines)
icons/EC2.json (231 lines)
icons/RDS.json (similar size)
Total: ~2000+ lines of JSON to process
- Extract elements from each JSON
- Calculate bounding boxes and offsets for each icon
- Transform all coordinates (x, y) for positioning
- Generate unique IDs for all elements
- Add arrows showing data flow
- Add text labels
- Generate final
.excalidraw file
Challenges with manual approach:
- High token consumption (~2000-5000 lines)
- Complex coordinate math
- Risk of ID conflicts
Supported Icon Libraries (Examples — verify availability)
- This workflow works with any valid
.excalidrawlib file you provide.
- Examples of library categories you may find on https://libraries.excalidraw.com/:
- Cloud service icons
- Kubernetes / infrastructure icons
- UI / Material icons
- Flowchart / diagram symbols
- Network diagram icons
- Availability and naming can change; verify exact library names on the site before use.
Fallback: No Icons Available
If no icon libraries are set up:
- Create diagrams using basic shapes (rectangles, ellipses, arrows)
- Use color coding and text labels to distinguish components
- Inform user they can add icons later or set up libraries for future diagrams
- The diagram will still be functional and clear, just less visually polished
References
See bundled references for:
references/excalidraw-schema.md - Complete Excalidraw JSON schema
references/element-types.md - Detailed element type specifications
templates/flowchart-template.json - Basic flowchart starter
templates/relationship-template.json - Relationship diagram starter
templates/mindmap-template.json - Mind map starter
scripts/split-excalidraw-library.py - Tool to split .excalidrawlib files
scripts/README.md - Documentation for library tools
scripts/.gitignore - Prevents local Python artifacts from being committed
Limitations
- Complex curves are simplified to straight/basic curved lines
- Hand-drawn roughness is set to default (1)
- No embedded images support in auto-generation
- Maximum recommended elements: 20 per diagram
- No automatic collision detection (use spacing guidelines)
Future Enhancements
Potential improvements:
- Auto-layout optimization algorithms
- Import from Mermaid/PlantUML syntax
- Template library expansion
- Interactive editing after generation
Related Skills
- frontend-design: Use it when the workflow also needs UI composition and front-end design direction.
- web-design-reviewer: Use it when the workflow also needs browser-based UI review and responsive QA.
- stitch-design: Use it when the workflow also needs turning interface designs into implementation-ready assets.
1---
2name: excalidraw-diagram-generator
3version: "2.0"
4last_updated: 2026-09-08
5tags: [excalidraw, diagram, generator, design, frontend]
6description: "Generate .excalidraw diagrams from natural language. Use when creating flowcharts, mind maps, system architecture diagrams, sequence diagrams, ER diagrams, network diagrams, or any visual process visualization."
7metadata:
8 source: https://skillmd.com/skills/practicalswan/excalidraw-diagram-generator
9---
10
11# Excalidraw Diagram Generator
12
13A skill for generating Excalidraw-format diagrams from natural language descriptions. This skill helps create visual representations of processes, systems, relationships, and ideas without manual drawing.
14
15- Leverage native parallel subagent dispatch and 200k+ context windows where available.
16
17
18
19## Activation Conditions
20
21Use symptom -> action triggers: when one matches, apply this skill and verify with the protocol below.
22
23Use this skill when users request:
24
25- "Create a diagram showing..."
26- "Make a flowchart for..."
27- "Visualize the process of..."
28- "Draw the system architecture of..."
29- "Generate a mind map about..."
30- "Create an Excalidraw file for..."
31- "Show the relationship between..."
32- "Diagram the workflow of..."
33
34**Supported diagram types:**
35- 📊 **Flowcharts**: Sequential processes, workflows, decision trees
36- 🔗 **Relationship Diagrams**: Entity relationships, system components, dependencies
37- 🧠 **Mind Maps**: Concept hierarchies, brainstorming results, topic organization
38- 🏗️ **Architecture Diagrams**: System design, module interactions, data flow
39- 📈 **Data Flow Diagrams (DFD)**: Data flow visualization, data transformation processes
40- 🏊 **Business Flow (Swimlane)**: Cross-functional workflows, actor-based process flows
41- 📦 **Class Diagrams**: Object-oriented design, class structures and relationships
42- 🔄 **Sequence Diagrams**: Object interactions over time, message flows
43- 🗃️ **ER Diagrams**: Database entity relationships, data models
44
45## Prerequisites
46
47- Clear description of what should be visualized
48- Identification of key entities, steps, or concepts
49- Understanding of relationships or flow between elements
50
51## Step-by-Step Workflow
52
53### Step 1: Understand the Request
54
55Analyze the user's description to determine:
561. **Diagram type** (flowchart, relationship, mind map, architecture)
572. **Key elements** (entities, steps, concepts)
583. **Relationships** (flow, connections, hierarchy)
594. **Complexity** (number of elements)
60
61### Step 2: Choose the Appropriate Diagram Type
62
63| User Intent | Diagram Type | Example Keywords |
64|-------------|--------------|------------------|
65| Process flow, steps, procedures | **Flowchart** | "workflow", "process", "steps", "procedure" |
66| Connections, dependencies, associations | **Relationship Diagram** | "relationship", "connections", "dependencies", "structure" |
67| Concept hierarchy, brainstorming | **Mind Map** | "mind map", "concepts", "ideas", "breakdown" |
68| System design, components | **Architecture Diagram** | "architecture", "system", "components", "modules" |
69| Data flow, transformation processes | **Data Flow Diagram (DFD)** | "data flow", "data processing", "data transformation" |
70| Cross-functional processes, actor responsibilities | **Business Flow (Swimlane)** | "business process", "swimlane", "actors", "responsibilities" |
71| Object-oriented design, class structures | **Class Diagram** | "class", "inheritance", "OOP", "object model" |
72| Interaction sequences, message flows | **Sequence Diagram** | "sequence", "interaction", "messages", "timeline" |
73| Database design, entity relationships | **ER Diagram** | "database", "entity", "relationship", "data model" |
74
75### Step 3: Extract Structured Information
76
77**For Flowcharts:**
78- List of sequential steps
79- Decision points (if any)
80- Start and end points
81
82**For Relationship Diagrams:**
83- Entities/nodes (name + optional description)
84- Relationships between entities (from → to, with label)
85
86**For Mind Maps:**
87- Central topic
88- Main branches (3-6 recommended)
89- Sub-topics for each branch (optional)
90
91**For Data Flow Diagrams (DFD):**
92- Data sources and destinations (external entities)
93- Processes (data transformations)
94- Data stores (databases, files)
95- Data flows (arrows showing data movement from left-to-right or from top-left to bottom-right)
96- **Important**: Do not represent process order, only data flow
97
98**For Business Flow (Swimlane):**
99- Actors/roles (departments, systems, people) - displayed as header columns
100- Process lanes (vertical lanes under each actor)
101- Process boxes (activities within each lane)
102- Flow arrows (connecting process boxes, including cross-lane handoffs)
103
104**For Class Diagrams:**
105- Classes with names
106- Attributes with visibility (+, -, #)
107- Methods with visibility and parameters
108- Relationships: inheritance (solid line + white triangle), implementation (dashed line + white triangle), association (solid line), dependency (dashed line), aggregation (solid line + white diamond), composition (solid line + filled diamond)
109- Multiplicity notations (1, 0..1, 1..*, *)
110
111**For Sequence Diagrams:**
112- Objects/actors (arranged horizontally at top)
113- Lifelines (vertical lines from each object)
114- Messages (horizontal arrows between lifelines)
115- Synchronous messages (solid arrow), asynchronous messages (dashed arrow)
116- Return values (dashed arrows)
117- Activation boxes (rectangles on lifelines during execution)
118- Time flows from top to bottom
119
120**For ER Diagrams:**
121- Entities (rectangles with entity names)
122- Attributes (listed inside entities)
123- Primary keys (underlined or marked with PK)
124- Foreign keys (marked with FK)
125- Relationships (lines connecting entities)
126- Cardinality: 1:1 (one-to-one), 1:N (one-to-many), N:M (many-to-many)
127- Junction/associative entities for many-to-many relationships (dashed rectangles)
128
129### Step 4: Generate the Excalidraw JSON
130
131Create the `.excalidraw` file with appropriate elements:
132
133**Available element types:**
134- `rectangle`: Boxes for entities, steps, concepts
135- `ellipse`: Alternative shapes for emphasis
136- `diamond`: Decision points
137- `arrow`: Directional connections
138- `text`: Labels and annotations
139
140**Key properties to set:**
141- **Position**: `x`, `y` coordinates
142- **Size**: `width`, `height`
143- **Style**: `strokeColor`, `backgroundColor`, `fillStyle`
144- **Font**: `fontFamily: 5` (Excalifont - **required for all text elements**)
145- **Text**: Embedded text for labels
146- **Connections**: `points` array for arrows
147
148**Important**: All text elements must use `fontFamily: 5` (Excalifont) for consistent visual appearance.
149
150### Step 5: Format the Output
151
152Structure the complete Excalidraw file:
153
154```json
155{
156 "type": "excalidraw",
157 "version": 2,
158 "source": "https://excalidraw.com",
159 "elements": [
160 // Array of diagram elements
161 ],
162 "appState": {
163 "viewBackgroundColor": "#ffffff",
164 "gridSize": 20
165 },
166 "files": {}
167}
168```
169
170### Step 6: Save and Provide Instructions
171
1721. Save as `<descriptive-name>.excalidraw`
1732. Inform user how to open:
174 - Visit https://excalidraw.com
175 - Click "Open" or drag-and-drop the file
176 - Or use Excalidraw VS Code extension
177
178## Best Practices
179
180### Element Count Guidelines
181
182| Diagram Type | Recommended Count | Maximum |
183|--------------|-------------------|---------|
184| Flowchart steps | 3-10 | 15 |
185| Relationship entities | 3-8 | 12 |
186| Mind map branches | 4-6 | 8 |
187| Mind map sub-topics per branch | 2-4 | 6 |
188
189### Layout Tips
190
1911. **Start positions**: Center important elements, use consistent spacing
1922. **Spacing**:
193 - Horizontal gap: 200-300px between elements
194 - Vertical gap: 100-150px between rows
1953. **Colors**: Use consistent color scheme
196 - Primary elements: Light blue (`#a5d8ff`)
197 - Secondary elements: Light green (`#b2f2bb`)
198 - Important/Central: Yellow (`#ffd43b`)
199 - Alerts/Warnings: Light red (`#ffc9c9`)
2004. **Text sizing**: 16-24px for readability
2015. **Font**: Always use `fontFamily: 5` (Excalifont) for all text elements
2026. **Arrow style**: Use straight arrows for simple flows, curved for complex relationships
203
204### Complexity Management
205
206**If user request has too many elements:**
207- Suggest breaking into multiple diagrams
208- Focus on main elements first
209- Offer to create detailed sub-diagrams
210
211**Example response:**
212```
213"Your request includes 15 components. For clarity, I recommend:
2141. High-level architecture diagram (6 main components)
2152. Detailed diagram for each subsystem
216
217Would you like me to start with the high-level view?"
218```
219
220<!-- MCP:START -->
221
222<!-- PORTABILITY:START -->
223## Cross-Client Portability
224
225This skill is written to stay usable across GitHub Copilot, Claude Code, and Codex.
226
227- GitHub Copilot: keep the folder in a Copilot-visible skill path or wrap the
228 workflow in project instructions when folder discovery is unavailable.
229- Claude Code: keep the folder in a local skills directory or a compatible plugin source.
230- Codex: install or sync the folder into
231 `$CODEX_HOME/skills/excalidraw-diagram-generator` and restart Codex after major changes.
232
233<!-- PORTABILITY:END -->
234
235## MCP Availability And Fallback
236
237Preferred MCP Server: None required
238
239- Fallback prompt: "Use the Excalidraw Diagram Generator skill without MCP. Rely on its local instructions, bundled resources, standard shell or editor tools, and direct verification. Show the evidence used before concluding."
240- Do not claim an MCP operation was used when the active host does not expose it.
241- Treat local files, tests, rendered outputs, logs, or screenshots as the fallback evidence path.
242
243<!-- MCP:END -->
244
245## Anti-Patterns
246
247- Starting from a generic template without adapting it: The output may look polished but still miss the real audience or medium.
248- Ignoring final render or export review: Layout bugs often appear only after the asset is opened in its destination tool.
249- Fixing content and presentation in one pass: It becomes hard to tell whether a problem is structural or visual.
250
251## Verification Protocol
252
253Before claiming "skill applied successfully":
254
2551. Pass/fail: The Excalidraw Diagram Generator implementation names the target runtime, framework version, and affected files.
2562. Pass/fail: Build, lint, test, or equivalent local validation is run for the changed surface.
2573. Pass/fail: Edge cases for errors, dependency drift, and environment differences are addressed or explicitly out of scope.
2584. Pressure-test scenario: Apply the workflow to a change that passes happy-path tests but fails one boundary condition.
2595. Success metric: Zero untested success claims; every implementation claim maps to a command or artifact.
260
261## Example Prompts and Responses
262
263### Example 1: Simple Flowchart
264
265**User:** "Create a flowchart for user registration"
266
267**Agent generates:**
2681. Extract steps: "Enter email" → "Verify email" → "Set password" → "Complete"
2692. Create flowchart with 4 rectangles + 3 arrows
2703. Save as `user-registration-flow.excalidraw`
271
272### Example 2: Relationship Diagram
273
274**User:** "Diagram the relationship between User, Post, and Comment entities"
275
276**Agent generates:**
2771. Entities: User, Post, Comment
2782. Relationships: User → Post ("creates"), User → Comment ("writes"), Post → Comment ("contains")
2793. Save as `user-content-relationships.excalidraw`
280
281### Example 3: Mind Map
282
283**User:** "Mind map about machine learning concepts"
284
285**Agent generates:**
2861. Center: "Machine Learning"
2872. Branches: Supervised Learning, Unsupervised Learning, Reinforcement Learning, Deep Learning
2883. Sub-topics under each branch
2894. Save as `machine-learning-mindmap.excalidraw`
290
291## Troubleshooting
292
293| Issue | Solution |
294|-------|----------|
295| Elements overlap | Increase spacing between coordinates |
296| Text doesn't fit in boxes | Increase box width or reduce font size |
297| Too many elements | Break into multiple diagrams |
298| Unclear layout | Use grid layout (rows/columns) or radial layout (mind maps) |
299| Colors inconsistent | Define color palette upfront based on element types |
300
301## Advanced Techniques
302
303### Grid Layout (for Relationship Diagrams)
304```javascript
305const columns = Math.ceil(Math.sqrt(entityCount));
306const x = startX + (index % columns) * horizontalGap;
307const y = startY + Math.floor(index / columns) * verticalGap;
308```
309
310### Radial Layout (for Mind Maps)
311```javascript
312const angle = (2 * Math.PI * index) / branchCount;
313const x = centerX + radius * Math.cos(angle);
314const y = centerY + radius * Math.sin(angle);
315```
316
317### Auto-generated IDs
318Use timestamp + random string for unique IDs:
319```javascript
320const id = Date.now().toString(36) + Math.random().toString(36).substr(2);
321```
322
323## Output Format
324
325Always provide:
3261. ✅ Complete `.excalidraw` JSON file
3272. 📊 Summary of what was created
3283. 📝 Element count
3294. 💡 Instructions for opening/editing
330
331**Example summary:**
332```
333Created: user-workflow.excalidraw
334Type: Flowchart
335Elements: 7 rectangles, 6 arrows, 1 title text
336Total: 14 elements
337
338To view:
3391. Visit https://excalidraw.com
3402. Drag and drop user-workflow.excalidraw
3413. Or use File → Open in Excalidraw VS Code extension
342```
343
344## Validation Checklist
345
346Before delivering the diagram:
347- [ ] All elements have unique IDs
348- [ ] Coordinates prevent overlapping
349- [ ] Text is readable (font size 16+)
350- [ ] **All text elements use `fontFamily: 5` (Excalifont)**
351- [ ] Arrows connect logically
352- [ ] Colors follow consistent scheme
353- [ ] File is valid JSON
354- [ ] Element count is reasonable (<20 for clarity)
355
356## Icon Libraries (Optional Enhancement)
357
358For specialized diagrams (e.g., AWS/GCP/Azure architecture diagrams), you can use pre-made icon libraries from Excalidraw. This provides professional, standardized icons instead of basic shapes.
359
360### When User Requests Icons
361
362**If user asks for AWS/cloud architecture diagrams or mentions wanting to use specific icons:**
363
3641. **Check if library exists**: Look for `libraries/<library-name>/reference.md`
3652. **If library exists**: Proceed to use icons (see AI Assistant Workflow below)
3663. **If library does NOT exist**: Respond with setup instructions:
367
368 ```
369 To use [AWS/GCP/Azure/etc.] architecture icons, please follow these steps:
370
371 1. Visit https://libraries.excalidraw.com/
372 2. Search for "[AWS Architecture Icons/etc.]" and download the .excalidrawlib file
373 3. Create directory: skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
374 4. Place the downloaded file in that directory
375 5. Run the splitter script:
376 python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
377
378 This will split the library into individual icon files for efficient use.
379 After setup is complete, I can create your diagram using the actual AWS/cloud icons.
380
381 Alternatively, I can create the diagram now using simple shapes (rectangles, ellipses)
382 which you can later replace with icons manually in Excalidraw.
383 ```
384
385### User Setup Instructions (Detailed)
386
387**Step 1: Create Library Directory**
388```bash
389mkdir -p skills/excalidraw-diagram-generator/libraries/aws-architecture-icons
390```
391
392**Step 2: Download Library**
393- Visit: https://libraries.excalidraw.com/
394- Search for your desired icon set (e.g., "AWS Architecture Icons")
395- Click download to get the `.excalidrawlib` file
396- Example categories (availability varies; confirm on the site):
397 - Cloud service icons
398 - UI/Material icons
399 - Flowchart symbols
400
401**Step 3: Place Library File**
402- Rename the downloaded file to match the directory name (e.g., `aws-architecture-icons.excalidrawlib`)
403- Move it to the directory created in Step 1
404
405**Step 4: Run Splitter Script**
406```bash
407python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
408```
409
410**Step 5: Verify Setup**
411After running the script, verify the following structure exists:
412```
413skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
414 aws-architecture-icons.excalidrawlib (original)
415 reference.md (generated - icon lookup table)
416 icons/ (generated - individual icon files)
417 API-Gateway.json
418 CloudFront.json
419 EC2.json
420 Lambda.json
421 RDS.json
422 S3.json
423 ...
424```
425
426### AI Assistant Workflow
427
428**When icon libraries are available in `libraries/`:**
429
430**RECOMMENDED APPROACH: Use Python Scripts (Efficient & Reliable)**
431
432The repository includes Python scripts that handle icon integration automatically:
433
4341. **Create base diagram structure**:
435 - Create `.excalidraw` file with basic layout (title, boxes, regions)
436 - This establishes the canvas and overall structure
437
4382. **Add icons using Python script**:
439 ```bash
440 python skills/excalidraw-diagram-generator/scripts/add-icon-to-diagram.py \
441 <diagram-path> <icon-name> <x> <y> [--label "Text"] [--library-path PATH]
442 ```
443 - Edit via `.excalidraw.edit` is enabled by default to avoid overwrite issues; pass `--no-use-edit-suffix` to disable.
444
445 **Examples**:
446 ```bash
447 # Add EC2 icon at position (400, 300) with label
448 python scripts/add-icon-to-diagram.py diagram.excalidraw EC2 400 300 --label "Web Server"
449
450 # Add VPC icon at position (200, 150)
451 python scripts/add-icon-to-diagram.py diagram.excalidraw VPC 200 150
452
453 # Add icon from different library
454 python scripts/add-icon-to-diagram.py diagram.excalidraw Compute-Engine 500 200 \
455 --library-path libraries/gcp-icons --label "API Server"
456 ```
457
4583. **Add connecting arrows**:
459 ```bash
460 python skills/excalidraw-diagram-generator/scripts/add-arrow.py \
461 <diagram-path> <from-x> <from-y> <to-x> <to-y> [--label "Text"] [--style solid|dashed|dotted] [--color HEX]
462 ```
463 - Edit via `.excalidraw.edit` is enabled by default to avoid overwrite issues; pass `--no-use-edit-suffix` to disable.
464
465 **Examples**:
466 ```bash
467 # Simple arrow from (300, 250) to (500, 300)
468 python scripts/add-arrow.py diagram.excalidraw 300 250 500 300
469
470 # Arrow with label
471 python scripts/add-arrow.py diagram.excalidraw 300 250 500 300 --label "HTTPS"
472
473 # Dashed arrow with custom color
474 python scripts/add-arrow.py diagram.excalidraw 400 350 600 400 --style dashed --color "#7950f2"
475 ```
476
4774. **Workflow summary**:
478 ```bash
479 # Step 1: Create base diagram with title and structure
480 # (Create .excalidraw file with initial elements)
481
482 # Step 2: Add icons with labels
483 python scripts/add-icon-to-diagram.py my-diagram.excalidraw "Internet-gateway" 200 150 --label "Internet Gateway"
484 python scripts/add-icon-to-diagram.py my-diagram.excalidraw VPC 250 250
485 python scripts/add-icon-to-diagram.py my-diagram.excalidraw ELB 350 300 --label "Load Balancer"
486 python scripts/add-icon-to-diagram.py my-diagram.excalidraw EC2 450 350 --label "EC2 Instance"
487 python scripts/add-icon-to-diagram.py my-diagram.excalidraw RDS 550 400 --label "Database"
488
489 # Step 3: Add connecting arrows
490 python scripts/add-arrow.py my-diagram.excalidraw 250 200 300 250 # Internet → VPC
491 python scripts/add-arrow.py my-diagram.excalidraw 300 300 400 300 # VPC → ELB
492 python scripts/add-arrow.py my-diagram.excalidraw 400 330 500 350 # ELB → EC2
493 python scripts/add-arrow.py my-diagram.excalidraw 500 380 600 400 # EC2 → RDS
494 ```
495
496**Benefits of Python Script Approach**:
497- ✅ **No token consumption**: Icon JSON data (200-1000 lines each) never enters AI context
498- ✅ **Accurate transformations**: Coordinate calculations handled deterministically
499- ✅ **ID management**: Automatic UUID generation prevents conflicts
500- ✅ **Reliable**: No risk of coordinate miscalculation or ID collision
501- ✅ **Fast**: Direct file manipulation, no parsing overhead
502- ✅ **Reusable**: Works with any Excalidraw library you provide
503
504**ALTERNATIVE: Manual Icon Integration (Not Recommended)**
505
506Only use this if Python scripts are unavailable:
507
5081. **Check for libraries**:
509 ```
510 List directory: skills/excalidraw-diagram-generator/libraries/
511 Look for subdirectories containing reference.md files
512 ```
513
5142. **Read reference.md**:
515 ```
516 Open: libraries/<library-name>/reference.md
517 This is lightweight (typically <300 lines) and lists all available icons
518 ```
519
5203. **Find relevant icons**:
521 ```
522 Search the reference.md table for icon names matching diagram needs
523 Example: For AWS diagram with EC2, S3, Lambda → Find "EC2", "S3", "Lambda" in table
524 ```
525
5264. **Load specific icon data** (WARNING: Large files):
527 ```
528 Read ONLY the needed icon files:
529 - libraries/aws-architecture-icons/icons/EC2.json (200-300 lines)
530 - libraries/aws-architecture-icons/icons/S3.json (200-300 lines)
531 - libraries/aws-architecture-icons/icons/Lambda.json (200-300 lines)
532 Note: Each icon file is 200-1000 lines - this consumes significant tokens
533 ```
534
5355. **Extract and transform elements**:
536 ```
537 Each icon JSON contains an "elements" array
538 Calculate bounding box (min_x, min_y, max_x, max_y)
539 Apply offset to all x/y coordinates
540 Generate new unique IDs for all elements
541 Update groupIds references
542 Copy transformed elements into your diagram
543 ```
544
5456. **Position icons and add connections**:
546 ```
547 Adjust x/y coordinates to position icons correctly in the diagram
548 Update IDs to ensure uniqueness across diagram
549 Add connecting arrows and labels as needed
550 ```
551
552**Manual Integration Challenges**:
553- ⚠️ High token consumption (200-1000 lines per icon × number of icons)
554- ⚠️ Complex coordinate transformation calculations
555- ⚠️ Risk of ID collision if not handled carefully
556- ⚠️ Time-consuming for diagrams with many icons
557
558### Example: Creating AWS Diagram with Icons
559
560**Request**: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
561
562**Recommended Workflow (using Python scripts)**:
563**Request**: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
564
565**Recommended Workflow (using Python scripts)**:
566
567```bash
568# Step 1: Create base diagram file with title
569# Create my-aws-diagram.excalidraw with basic structure (title, etc.)
570
571# Step 2: Check icon availability
572# Read: libraries/aws-architecture-icons/reference.md
573# Confirm icons exist: Internet-gateway, VPC, ELB, EC2, RDS
574
575# Step 3: Add icons with Python script
576python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw "Internet-gateway" 150 100 --label "Internet Gateway"
577python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw VPC 200 200
578python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw ELB 350 250 --label "Load Balancer"
579python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw EC2 500 300 --label "Web Server"
580python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw RDS 650 350 --label "Database"
581
582# Step 4: Add connecting arrows
583python scripts/add-arrow.py my-aws-diagram.excalidraw 200 150 250 200 # Internet → VPC
584python scripts/add-arrow.py my-aws-diagram.excalidraw 265 230 350 250 # VPC → ELB
585python scripts/add-arrow.py my-aws-diagram.excalidraw 415 280 500 300 # ELB → EC2
586python scripts/add-arrow.py my-aws-diagram.excalidraw 565 330 650 350 --label "SQL" --style dashed
587
588# Result: Complete diagram with professional AWS icons, labels, and connections
589```
590
591**Benefits**:
592- No manual coordinate calculation
593- No token consumption for icon data
594- Deterministic, reliable results
595- Easy to iterate and adjust positions
596
597**Alternative Workflow (manual, if scripts unavailable)**:
5981. Check: `libraries/aws-architecture-icons/reference.md` exists → Yes
5992. Read reference.md → Find entries for Internet-gateway, VPC, ELB, EC2, RDS
6003. Load:
601 - `icons/Internet-gateway.json` (298 lines)
602 - `icons/VPC.json` (550 lines)
603 - `icons/ELB.json` (363 lines)
604 - `icons/EC2.json` (231 lines)
605 - `icons/RDS.json` (similar size)
606 **Total: ~2000+ lines of JSON to process**
6074. Extract elements from each JSON
6085. Calculate bounding boxes and offsets for each icon
6096. Transform all coordinates (x, y) for positioning
6107. Generate unique IDs for all elements
6118. Add arrows showing data flow
6129. Add text labels
61310. Generate final `.excalidraw` file
614
615**Challenges with manual approach**:
616- High token consumption (~2000-5000 lines)
617- Complex coordinate math
618- Risk of ID conflicts
619
620### Supported Icon Libraries (Examples — verify availability)
621
622- This workflow works with any valid `.excalidrawlib` file you provide.
623- Examples of library categories you may find on https://libraries.excalidraw.com/:
624 - Cloud service icons
625 - Kubernetes / infrastructure icons
626 - UI / Material icons
627 - Flowchart / diagram symbols
628 - Network diagram icons
629- Availability and naming can change; verify exact library names on the site before use.
630
631### Fallback: No Icons Available
632
633**If no icon libraries are set up:**
634- Create diagrams using basic shapes (rectangles, ellipses, arrows)
635- Use color coding and text labels to distinguish components
636- Inform user they can add icons later or set up libraries for future diagrams
637- The diagram will still be functional and clear, just less visually polished
638
639## References
640
641See bundled references for:
642- `references/excalidraw-schema.md` - Complete Excalidraw JSON schema
643- `references/element-types.md` - Detailed element type specifications
644- `templates/flowchart-template.json` - Basic flowchart starter
645- `templates/relationship-template.json` - Relationship diagram starter
646- `templates/mindmap-template.json` - Mind map starter
647- `scripts/split-excalidraw-library.py` - Tool to split `.excalidrawlib` files
648- `scripts/README.md` - Documentation for library tools
649- `scripts/.gitignore` - Prevents local Python artifacts from being committed
650
651## Limitations
652
653- Complex curves are simplified to straight/basic curved lines
654- Hand-drawn roughness is set to default (1)
655- No embedded images support in auto-generation
656- Maximum recommended elements: 20 per diagram
657- No automatic collision detection (use spacing guidelines)
658
659## Future Enhancements
660
661Potential improvements:
662- Auto-layout optimization algorithms
663- Import from Mermaid/PlantUML syntax
664- Template library expansion
665- Interactive editing after generation
666
667
668---
669
670## Related Skills
671
672- [frontend-design](../frontend-design/SKILL.md): Use it when the workflow also needs UI composition and front-end design direction.
673- [web-design-reviewer](../web-design-reviewer/SKILL.md): Use it when the workflow also needs browser-based UI review and responsive QA.
674- [stitch-design](../stitch-design/SKILL.md): Use it when the workflow also needs turning interface designs into implementation-ready assets.