1---
2name: excalidraw-diagram-generator
3description: 'Generate Excalidraw diagrams from natural language descriptions. Use when asked to "create a diagram", "make a flowchart", "visualize a process", "draw a system architecture", "create a mind map", or "generate an Excalidraw file". Supports flowcharts, relationship diagrams, mind maps, and system architecture diagrams. Outputs .excalidraw JSON files that can be opened directly in Excalidraw.'
4---
5 
6# Excalidraw Diagram Generator
7 
8A 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.
9 
10## When to Use This Skill
11 
12Use this skill when users request:
13 
14- "Create a diagram showing..."
15- "Make a flowchart for..."
16- "Visualize the process of..."
17- "Draw the system architecture of..."
18- "Generate a mind map about..."
19- "Create an Excalidraw file for..."
20- "Show the relationship between..."
21- "Diagram the workflow of..."
22 
23**Supported diagram types:**
24- 📊 **Flowcharts**: Sequential processes, workflows, decision trees
25- 🔗 **Relationship Diagrams**: Entity relationships, system components, dependencies
26- 🧠 **Mind Maps**: Concept hierarchies, brainstorming results, topic organization
27- 🏗️ **Architecture Diagrams**: System design, module interactions, data flow
28- 📈 **Data Flow Diagrams (DFD)**: Data flow visualization, data transformation processes
29- 🏊 **Business Flow (Swimlane)**: Cross-functional workflows, actor-based process flows
30- 📦 **Class Diagrams**: Object-oriented design, class structures and relationships
31- 🔄 **Sequence Diagrams**: Object interactions over time, message flows
32- 🗃️ **ER Diagrams**: Database entity relationships, data models
33 
34## Prerequisites
35 
36- Clear description of what should be visualized
37- Identification of key entities, steps, or concepts
38- Understanding of relationships or flow between elements
39 
40## Step-by-Step Workflow
41 
42### Step 1: Understand the Request
43 
44Analyze the user's description to determine:
451. **Diagram type** (flowchart, relationship, mind map, architecture)
462. **Key elements** (entities, steps, concepts)
473. **Relationships** (flow, connections, hierarchy)
484. **Complexity** (number of elements)
49 
50### Step 2: Choose the Appropriate Diagram Type
51 
52| User Intent | Diagram Type | Example Keywords |
53|-------------|--------------|------------------|
54| Process flow, steps, procedures | **Flowchart** | "workflow", "process", "steps", "procedure" |
55| Connections, dependencies, associations | **Relationship Diagram** | "relationship", "connections", "dependencies", "structure" |
56| Concept hierarchy, brainstorming | **Mind Map** | "mind map", "concepts", "ideas", "breakdown" |
57| System design, components | **Architecture Diagram** | "architecture", "system", "components", "modules" |
58| Data flow, transformation processes | **Data Flow Diagram (DFD)** | "data flow", "data processing", "data transformation" |
59| Cross-functional processes, actor responsibilities | **Business Flow (Swimlane)** | "business process", "swimlane", "actors", "responsibilities" |
60| Object-oriented design, class structures | **Class Diagram** | "class", "inheritance", "OOP", "object model" |
61| Interaction sequences, message flows | **Sequence Diagram** | "sequence", "interaction", "messages", "timeline" |
62| Database design, entity relationships | **ER Diagram** | "database", "entity", "relationship", "data model" |
63 
64### Step 3: Extract Structured Information
65 
66**For Flowcharts:**
67- List of sequential steps
68- Decision points (if any)
69- Start and end points
70 
71**For Relationship Diagrams:**
72- Entities/nodes (name + optional description)
73- Relationships between entities (from → to, with label)
74 
75**For Mind Maps:**
76- Central topic
77- Main branches (3-6 recommended)
78- Sub-topics for each branch (optional)
79 
80**For Data Flow Diagrams (DFD):**
81- Data sources and destinations (external entities)
82- Processes (data transformations)
83- Data stores (databases, files)
84- Data flows (arrows showing data movement from left-to-right or from top-left to bottom-right)
85- **Important**: Do not represent process order, only data flow
86 
87**For Business Flow (Swimlane):**
88- Actors/roles (departments, systems, people) - displayed as header columns
89- Process lanes (vertical lanes under each actor)
90- Process boxes (activities within each lane)
91- Flow arrows (connecting process boxes, including cross-lane handoffs)
92 
93**For Class Diagrams:**
94- Classes with names
95- Attributes with visibility (+, -, #)
96- Methods with visibility and parameters
97- 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)
98- Multiplicity notations (1, 0..1, 1..*, *)
99 
100**For Sequence Diagrams:**
101- Objects/actors (arranged horizontally at top)
102- Lifelines (vertical lines from each object)
103- Messages (horizontal arrows between lifelines)
104- Synchronous messages (solid arrow), asynchronous messages (dashed arrow)
105- Return values (dashed arrows)
106- Activation boxes (rectangles on lifelines during execution)
107- Time flows from top to bottom
108 
109**For ER Diagrams:**
110- Entities (rectangles with entity names)
111- Attributes (listed inside entities)
112- Primary keys (underlined or marked with PK)
113- Foreign keys (marked with FK)
114- Relationships (lines connecting entities)
115- Cardinality: 1:1 (one-to-one), 1:N (one-to-many), N:M (many-to-many)
116- Junction/associative entities for many-to-many relationships (dashed rectangles)
117 
118### Step 4: Generate the Excalidraw JSON
119 
120Create the `.excalidraw` file with appropriate elements:
121 
122**Available element types:**
123- `rectangle`: Boxes for entities, steps, concepts
124- `ellipse`: Alternative shapes for emphasis
125- `diamond`: Decision points
126- `arrow`: Directional connections
127- `text`: Labels and annotations
128 
129**Key properties to set:**
130- **Position**: `x`, `y` coordinates
131- **Size**: `width`, `height`
132- **Style**: `strokeColor`, `backgroundColor`, `fillStyle`
133- **Font**: `fontFamily: 5` (Excalifont - **required for all text elements**)
134- **Text**: Embedded text for labels
135- **Connections**: `points` array for arrows
136 
137**Important**: All text elements must use `fontFamily: 5` (Excalifont) for consistent visual appearance.
138 
139### Step 5: Format the Output
140 
141Structure the complete Excalidraw file:
142 
143```json
144{
145  "type": "excalidraw",
146  "version": 2,
147  "source": "https://excalidraw.com",
148  "elements": [
149    // Array of diagram elements
150  ],
151  "appState": {
152    "viewBackgroundColor": "#ffffff",
153    "gridSize": 20
154  },
155  "files": {}
156}
157```
158 
159### Step 6: Save and Provide Instructions
160 
1611. Save as `<descriptive-name>.excalidraw`
1622. Inform user how to open:
163   - Visit https://excalidraw.com
164   - Click "Open" or drag-and-drop the file
165   - Or use Excalidraw VS Code extension
166 
167## Best Practices
168 
169### Element Count Guidelines
170 
171| Diagram Type | Recommended Count | Maximum |
172|--------------|-------------------|---------|
173| Flowchart steps | 3-10 | 15 |
174| Relationship entities | 3-8 | 12 |
175| Mind map branches | 4-6 | 8 |
176| Mind map sub-topics per branch | 2-4 | 6 |
177 
178### Layout Tips
179 
1801. **Start positions**: Center important elements, use consistent spacing
1812. **Spacing**: 
182   - Horizontal gap: 200-300px between elements
183   - Vertical gap: 100-150px between rows
1843. **Colors**: Use consistent color scheme
185   - Primary elements: Light blue (`#a5d8ff`)
186   - Secondary elements: Light green (`#b2f2bb`)
187   - Important/Central: Yellow (`#ffd43b`)
188   - Alerts/Warnings: Light red (`#ffc9c9`)
1894. **Text sizing**: 16-24px for readability
1905. **Font**: Always use `fontFamily: 5` (Excalifont) for all text elements
1916. **Arrow style**: Use straight arrows for simple flows, curved for complex relationships
192 
193### Complexity Management
194 
195**If user request has too many elements:**
196- Suggest breaking into multiple diagrams
197- Focus on main elements first
198- Offer to create detailed sub-diagrams
199 
200**Example response:**
201```
202"Your request includes 15 components. For clarity, I recommend:
2031. High-level architecture diagram (6 main components)
2042. Detailed diagram for each subsystem
205 
206Would you like me to start with the high-level view?"
207```
208 
209## Example Prompts and Responses
210 
211### Example 1: Simple Flowchart
212 
213**User:** "Create a flowchart for user registration"
214 
215**Agent generates:**
2161. Extract steps: "Enter email" → "Verify email" → "Set password" → "Complete"
2172. Create flowchart with 4 rectangles + 3 arrows
2183. Save as `user-registration-flow.excalidraw`
219 
220### Example 2: Relationship Diagram
221 
222**User:** "Diagram the relationship between User, Post, and Comment entities"
223 
224**Agent generates:**
2251. Entities: User, Post, Comment
2262. Relationships: User → Post ("creates"), User → Comment ("writes"), Post → Comment ("contains")
2273. Save as `user-content-relationships.excalidraw`
228 
229### Example 3: Mind Map
230 
231**User:** "Mind map about machine learning concepts"
232 
233**Agent generates:**
2341. Center: "Machine Learning"
2352. Branches: Supervised Learning, Unsupervised Learning, Reinforcement Learning, Deep Learning
2363. Sub-topics under each branch
2374. Save as `machine-learning-mindmap.excalidraw`
238 
239## Troubleshooting
240 
241| Issue | Solution |
242|-------|----------|
243| Elements overlap | Increase spacing between coordinates |
244| Text doesn't fit in boxes | Increase box width or reduce font size |
245| Too many elements | Break into multiple diagrams |
246| Unclear layout | Use grid layout (rows/columns) or radial layout (mind maps) |
247| Colors inconsistent | Define color palette upfront based on element types |
248 
249## Advanced Techniques
250 
251### Grid Layout (for Relationship Diagrams)
252```javascript
253const columns = Math.ceil(Math.sqrt(entityCount));
254const x = startX + (index % columns) * horizontalGap;
255const y = startY + Math.floor(index / columns) * verticalGap;
256```
257 
258### Radial Layout (for Mind Maps)
259```javascript
260const angle = (2 * Math.PI * index) / branchCount;
261const x = centerX + radius * Math.cos(angle);
262const y = centerY + radius * Math.sin(angle);
263```
264 
265### Auto-generated IDs
266Use timestamp + random string for unique IDs:
267```javascript
268const id = Date.now().toString(36) + Math.random().toString(36).substr(2);
269```
270 
271## Output Format
272 
273Always provide:
2741. ✅ Complete `.excalidraw` JSON file
2752. 📊 Summary of what was created
2763. 📝 Element count
2774. 💡 Instructions for opening/editing
278 
279**Example summary:**
280```
281Created: user-workflow.excalidraw
282Type: Flowchart
283Elements: 7 rectangles, 6 arrows, 1 title text
284Total: 14 elements
285 
286To view:
2871. Visit https://excalidraw.com
2882. Drag and drop user-workflow.excalidraw
2893. Or use File → Open in Excalidraw VS Code extension
290```
291 
292## Validation Checklist
293 
294Before delivering the diagram:
295- [ ] All elements have unique IDs
296- [ ] Coordinates prevent overlapping
297- [ ] Text is readable (font size 16+)
298- [ ] **All text elements use `fontFamily: 5` (Excalifont)**
299- [ ] Arrows connect logically
300- [ ] Colors follow consistent scheme
301- [ ] File is valid JSON
302- [ ] Element count is reasonable (<20 for clarity)
303 
304## Icon Libraries (Optional Enhancement)
305 
306For 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.
307 
308### When User Requests Icons
309 
310**If user asks for AWS/cloud architecture diagrams or mentions wanting to use specific icons:**
311 
3121. **Check if library exists**: Look for `libraries/<library-name>/reference.md`
3132. **If library exists**: Proceed to use icons (see AI Assistant Workflow below)
3143. **If library does NOT exist**: Respond with setup instructions:
315 
316   ```
317   To use [AWS/GCP/Azure/etc.] architecture icons, please follow these steps:
318   
319   1. Visit https://libraries.excalidraw.com/
320   2. Search for "[AWS Architecture Icons/etc.]" and download the .excalidrawlib file
321   3. Create directory: skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
322   4. Place the downloaded file in that directory
323   5. Run the splitter script:
324      python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/[icon-set-name]/
325   
326   This will split the library into individual icon files for efficient use.
327   After setup is complete, I can create your diagram using the actual AWS/cloud icons.
328   
329   Alternatively, I can create the diagram now using simple shapes (rectangles, ellipses) 
330   which you can later replace with icons manually in Excalidraw.
331   ```
332 
333### User Setup Instructions (Detailed)
334 
335**Step 1: Create Library Directory**
336```bash
337mkdir -p skills/excalidraw-diagram-generator/libraries/aws-architecture-icons
338```
339 
340**Step 2: Download Library**
341- Visit: https://libraries.excalidraw.com/
342- Search for your desired icon set (e.g., "AWS Architecture Icons")
343- Click download to get the `.excalidrawlib` file
344- Example categories (availability varies; confirm on the site):
345   - Cloud service icons
346   - UI/Material icons
347   - Flowchart symbols
348 
349**Step 3: Place Library File**
350- Rename the downloaded file to match the directory name (e.g., `aws-architecture-icons.excalidrawlib`)
351- Move it to the directory created in Step 1
352 
353**Step 4: Run Splitter Script**
354```bash
355python skills/excalidraw-diagram-generator/scripts/split-excalidraw-library.py skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
356```
357 
358**Step 5: Verify Setup**
359After running the script, verify the following structure exists:
360```
361skills/excalidraw-diagram-generator/libraries/aws-architecture-icons/
362  aws-architecture-icons.excalidrawlib  (original)
363  reference.md                          (generated - icon lookup table)
364  icons/                                (generated - individual icon files)
365    API-Gateway.json
366    CloudFront.json
367    EC2.json
368    Lambda.json
369    RDS.json
370    S3.json
371    ...
372```
373 
374### AI Assistant Workflow
375 
376**When icon libraries are available in `libraries/`:**
377 
378**RECOMMENDED APPROACH: Use Python Scripts (Efficient & Reliable)**
379 
380The repository includes Python scripts that handle icon integration automatically:
381 
3821. **Create base diagram structure**:
383   - Create `.excalidraw` file with basic layout (title, boxes, regions)
384   - This establishes the canvas and overall structure
385 
3862. **Add icons using Python script**:
387   ```bash
388   python skills/excalidraw-diagram-generator/scripts/add-icon-to-diagram.py \
389     <diagram-path> <icon-name> <x> <y> [--label "Text"] [--library-path PATH]
390   ```
391   - Edit via `.excalidraw.edit` is enabled by default to avoid overwrite issues; pass `--no-use-edit-suffix` to disable.
392   
393   **Examples**:
394   ```bash
395   # Add EC2 icon at position (400, 300) with label
396   python scripts/add-icon-to-diagram.py diagram.excalidraw EC2 400 300 --label "Web Server"
397   
398   # Add VPC icon at position (200, 150)
399   python scripts/add-icon-to-diagram.py diagram.excalidraw VPC 200 150
400   
401   # Add icon from different library
402   python scripts/add-icon-to-diagram.py diagram.excalidraw Compute-Engine 500 200 \
403     --library-path libraries/gcp-icons --label "API Server"
404   ```
405 
4063. **Add connecting arrows**:
407   ```bash
408   python skills/excalidraw-diagram-generator/scripts/add-arrow.py \
409     <diagram-path> <from-x> <from-y> <to-x> <to-y> [--label "Text"] [--style solid|dashed|dotted] [--color HEX]
410   ```
411   - Edit via `.excalidraw.edit` is enabled by default to avoid overwrite issues; pass `--no-use-edit-suffix` to disable.
412   
413   **Examples**:
414   ```bash
415   # Simple arrow from (300, 250) to (500, 300)
416   python scripts/add-arrow.py diagram.excalidraw 300 250 500 300
417   
418   # Arrow with label
419   python scripts/add-arrow.py diagram.excalidraw 300 250 500 300 --label "HTTPS"
420   
421   # Dashed arrow with custom color
422   python scripts/add-arrow.py diagram.excalidraw 400 350 600 400 --style dashed --color "#7950f2"
423   ```
424 
4254. **Workflow summary**:
426   ```bash
427   # Step 1: Create base diagram with title and structure
428   # (Create .excalidraw file with initial elements)
429   
430   # Step 2: Add icons with labels
431   python scripts/add-icon-to-diagram.py my-diagram.excalidraw "Internet-gateway" 200 150 --label "Internet Gateway"
432   python scripts/add-icon-to-diagram.py my-diagram.excalidraw VPC 250 250
433   python scripts/add-icon-to-diagram.py my-diagram.excalidraw ELB 350 300 --label "Load Balancer"
434   python scripts/add-icon-to-diagram.py my-diagram.excalidraw EC2 450 350 --label "EC2 Instance"
435   python scripts/add-icon-to-diagram.py my-diagram.excalidraw RDS 550 400 --label "Database"
436   
437   # Step 3: Add connecting arrows
438   python scripts/add-arrow.py my-diagram.excalidraw 250 200 300 250  # Internet → VPC
439   python scripts/add-arrow.py my-diagram.excalidraw 300 300 400 300  # VPC → ELB
440   python scripts/add-arrow.py my-diagram.excalidraw 400 330 500 350  # ELB → EC2
441   python scripts/add-arrow.py my-diagram.excalidraw 500 380 600 400  # EC2 → RDS
442   ```
443 
444**Benefits of Python Script Approach**:
445- ✅ **No token consumption**: Icon JSON data (200-1000 lines each) never enters AI context
446- ✅ **Accurate transformations**: Coordinate calculations handled deterministically
447- ✅ **ID management**: Automatic UUID generation prevents conflicts
448- ✅ **Reliable**: No risk of coordinate miscalculation or ID collision
449- ✅ **Fast**: Direct file manipulation, no parsing overhead
450- ✅ **Reusable**: Works with any Excalidraw library you provide
451 
452**ALTERNATIVE: Manual Icon Integration (Not Recommended)**
453 
454Only use this if Python scripts are unavailable:
455 
4561. **Check for libraries**: 
457   ```
458   List directory: skills/excalidraw-diagram-generator/libraries/
459   Look for subdirectories containing reference.md files
460   ```
461 
4622. **Read reference.md**:
463   ```
464   Open: libraries/<library-name>/reference.md
465   This is lightweight (typically <300 lines) and lists all available icons
466   ```
467 
4683. **Find relevant icons**:
469   ```
470   Search the reference.md table for icon names matching diagram needs
471   Example: For AWS diagram with EC2, S3, Lambda → Find "EC2", "S3", "Lambda" in table
472   ```
473 
4744. **Load specific icon data** (WARNING: Large files):
475   ```
476   Read ONLY the needed icon files:
477   - libraries/aws-architecture-icons/icons/EC2.json (200-300 lines)
478   - libraries/aws-architecture-icons/icons/S3.json (200-300 lines)
479   - libraries/aws-architecture-icons/icons/Lambda.json (200-300 lines)
480   Note: Each icon file is 200-1000 lines - this consumes significant tokens
481   ```
482 
4835. **Extract and transform elements**:
484   ```
485   Each icon JSON contains an "elements" array
486   Calculate bounding box (min_x, min_y, max_x, max_y)
487   Apply offset to all x/y coordinates
488   Generate new unique IDs for all elements
489   Update groupIds references
490   Copy transformed elements into your diagram
491   ```
492 
4936. **Position icons and add connections**:
494   ```
495   Adjust x/y coordinates to position icons correctly in the diagram
496   Update IDs to ensure uniqueness across diagram
497   Add connecting arrows and labels as needed
498   ```
499 
500**Manual Integration Challenges**:
501- ⚠️ High token consumption (200-1000 lines per icon × number of icons)
502- ⚠️ Complex coordinate transformation calculations
503- ⚠️ Risk of ID collision if not handled carefully
504- ⚠️ Time-consuming for diagrams with many icons
505 
506### Example: Creating AWS Diagram with Icons
507 
508**Request**: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
509 
510**Recommended Workflow (using Python scripts)**:
511**Request**: "Create an AWS architecture diagram with Internet Gateway, VPC, ELB, EC2, and RDS"
512 
513**Recommended Workflow (using Python scripts)**:
514 
515```bash
516# Step 1: Create base diagram file with title
517# Create my-aws-diagram.excalidraw with basic structure (title, etc.)
518 
519# Step 2: Check icon availability
520# Read: libraries/aws-architecture-icons/reference.md
521# Confirm icons exist: Internet-gateway, VPC, ELB, EC2, RDS
522 
523# Step 3: Add icons with Python script
524python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw "Internet-gateway" 150 100 --label "Internet Gateway"
525python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw VPC 200 200
526python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw ELB 350 250 --label "Load Balancer"
527python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw EC2 500 300 --label "Web Server"
528python scripts/add-icon-to-diagram.py my-aws-diagram.excalidraw RDS 650 350 --label "Database"
529 
530# Step 4: Add connecting arrows
531python scripts/add-arrow.py my-aws-diagram.excalidraw 200 150 250 200  # Internet → VPC
532python scripts/add-arrow.py my-aws-diagram.excalidraw 265 230 350 250  # VPC → ELB
533python scripts/add-arrow.py my-aws-diagram.excalidraw 415 280 500 300  # ELB → EC2
534python scripts/add-arrow.py my-aws-diagram.excalidraw 565 330 650 350 --label "SQL" --style dashed
535 
536# Result: Complete diagram with professional AWS icons, labels, and connections
537```
538 
539**Benefits**:
540- No manual coordinate calculation
541- No token consumption for icon data
542- Deterministic, reliable results
543- Easy to iterate and adjust positions
544 
545**Alternative Workflow (manual, if scripts unavailable)**:
5461. Check: `libraries/aws-architecture-icons/reference.md` exists → Yes
5472. Read reference.md → Find entries for Internet-gateway, VPC, ELB, EC2, RDS
5483. Load:
549   - `icons/Internet-gateway.json` (298 lines)
550   - `icons/VPC.json` (550 lines)
551   - `icons/ELB.json` (363 lines)
552   - `icons/EC2.json` (231 lines) 
553   - `icons/RDS.json` (similar size)
554   **Total: ~2000+ lines of JSON to process**
5554. Extract elements from each JSON
5565. Calculate bounding boxes and offsets for each icon
5576. Transform all coordinates (x, y) for positioning
5587. Generate unique IDs for all elements
5598. Add arrows showing data flow
5609. Add text labels
56110. Generate final `.excalidraw` file
562 
563**Challenges with manual approach**:
564- High token consumption (~2000-5000 lines)
565- Complex coordinate math
566- Risk of ID conflicts
567 
568### Supported Icon Libraries (Examples — verify availability)
569 
570- This workflow works with any valid `.excalidrawlib` file you provide.
571- Examples of library categories you may find on https://libraries.excalidraw.com/:
572   - Cloud service icons
573   - Kubernetes / infrastructure icons
574   - UI / Material icons
575   - Flowchart / diagram symbols
576   - Network diagram icons
577- Availability and naming can change; verify exact library names on the site before use.
578 
579### Fallback: No Icons Available
580 
581**If no icon libraries are set up:**
582- Create diagrams using basic shapes (rectangles, ellipses, arrows)
583- Use color coding and text labels to distinguish components
584- Inform user they can add icons later or set up libraries for future diagrams
585- The diagram will still be functional and clear, just less visually polished
586 
587## References
588 
589See bundled references for:
590- `references/excalidraw-schema.md` - Complete Excalidraw JSON schema
591- `references/element-types.md` - Detailed element type specifications
592- `templates/flowchart-template.json` - Basic flowchart starter
593- `templates/relationship-template.json` - Relationship diagram starter
594- `templates/mindmap-template.json` - Mind map starter
595- `scripts/split-excalidraw-library.py` - Tool to split `.excalidrawlib` files
596- `scripts/README.md` - Documentation for library tools
597- `scripts/.gitignore` - Prevents local Python artifacts from being committed
598 
599## Limitations
600 
601- Complex curves are simplified to straight/basic curved lines
602- Hand-drawn roughness is set to default (1)
603- No embedded images support in auto-generation
604- Maximum recommended elements: 20 per diagram
605- No automatic collision detection (use spacing guidelines)
606 
607## Future Enhancements
608 
609Potential improvements:
610- Auto-layout optimization algorithms
611- Import from Mermaid/PlantUML syntax
612- Template library expansion
613- Interactive editing after generation
614