Skip to content
Back to search

visual-explainer-skill

A Claude Code skill that transforms any content or Mermaid diagram into stunning visual explanations — whiteboard sketches, infographics, mind maps, and more — powered by OpenAI or Gemini image generation.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ericblue--visual-explainer-skill/badge.svg)](/listings/ericblue--visual-explainer-skill)

HTML

<a href="/listings/ericblue--visual-explainer-skill"><img src="/api/listings/ericblue--visual-explainer-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Claude Code

git clone <repo-url> && cd visual-explainer-skill
make install

Or manually:

cp skill/visual-explainer.md ~/.claude/commands/visual-explainer.md

The skill will be available immediately as `/visual-explainer` in any Claude Code session.

OpenClaw

make openclaw-install

Or manually:

mkdir -p ~/clawd/skills/visual-explainer
cp skill/visual-explainer.md ~/clawd/skills/visual-explainer/SKILL.md

Makefile targets

| Target | Description | |--------|-------------| | **Claude Code** | | | `make install` | Install to `~/.claude/commands/` | | `make uninstall` | Remove from `~/.claude/commands/` | | **OpenClaw** | | | `make openclaw-install` | Install to `~/clawd/skills/` | | `make openclaw-uninstall` | Remove from `~/clawd/skills/` | | `make openclaw-check` | Check install status | | **General** | | | `make info` | Show skill name, version, author, and available styles | | `make version` | Print the current version | | `make check` | Verify prerequisites (jq, skill files, OPENAI_API_KEY) |

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 525 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Visual Explainer Skill
  2. A Claude Code skill that converts any content into stunning visual explanations — whiteboard sketches, professional infographics, presentation slides, technical diagrams, mind maps, and UI wireframe mockups — powered by OpenAI's gpt-image-1.5 or Google Gemini's Nano Banana 2.
  3. ## About
  4. AI-generated visual explanations have exploded in popularity — tools like NotebookLM and Gemini can turn documents into polished infographics and whiteboard sketches. But these tools are closed ecosystems. You can't customize the output style, integrate them into your dev workflow, or control the prompts that drive the generation.
  5. **Visual Explainer** brings this capability directly into Claude Code as a slash command. It takes any content — a topic, a document, meeting notes, a codebase — and transforms it into a rich visual explanation using OpenAI's gpt-image-1.5 model.
  6. The core insight is that image generation quality depends almost entirely on prompt quality. Visual Explainer uses deeply structured, 400-800 word prompts with explicit spatial layout, icon descriptions, color palettes, typography, and connections — producing results that rival or exceed what dedicated visual AI tools generate.
  7. ### Design Principles
  8. - **Style Spectrum** — From rough whiteboard sketches to polished infographics, with a `--draw-level` parameter to control exactly where on the hand-drawn-to-professional spectrum the output lands
  9. - **Deep Content Analysis** — Every generation starts with structured extraction of concepts, relationships, visual metaphors, and layout strategy before any prompt is written
  10. - **Prompt Engineering as the Product** — The skill's value is in its style-specific prompt templates, not just API wrappers. Each style (whiteboard, infographic, presentation, diagram, mindmap, mindmap-structured, mockup) has a comprehensive template tuned for that visual language
  11. - **Composable with Documents** — Works naturally with Claude Code's ability to read files, so you can point it at any existing doc, spec, or codebase and generate visuals from it
  12. ### Author
  13. Created by [Eric Blue](https://about.ericblue.com) ([GitHub](https://github.com/ericblue))
  14. ## Example Gallery
  15. ### Whiteboard — How DNS Resolution Works
  16. Hand-drawn, colorful, educator-style — like walking into a classroom with an amazing whiteboard illustration.
  17. <img src="examples/01-whiteboard-dns/visual-explainer-1.png" width="600" alt="Whiteboard: DNS Resolution">
  18. ### Infographic — The Foundations of Machine Learning
  19. Clean, structured, publication-quality — numbered sections, flat-design icons, cohesive color palettes.
  20. <img src="examples/02-infographic-ml/visual-explainer-1.png" width="400" alt="Infographic: Machine Learning">
  21. ### Whiteboard (Sketch) — How Git Branching Works
  22. Rougher hand-drawn feel with `--draw-level sketch` — casual, playful, like a developer sketching during standup.
  23. <img src="examples/03-sketch-git/visual-explainer-1.png" width="600" alt="Sketch: Git Branching">
  24. ### Diagram — Kubernetes Pod Networking
  25. Precise, technical, well-labeled architecture diagram with `--complexity detailed` — layered layout with color-coded legend.
  26. <img src="examples/04-diagram-k8s/visual-explainer-1.png" width="500" alt="Diagram: K8s Networking">
  27. ### Multi-Frame — OAuth2 Authorization Code Flow
  28. Progressive build-up with `--mode multi-frame` — 3 frames that introduce actors, show the flow, then present the complete picture.
  29. <p>
  30. <img src="examples/05-multiframe-oauth/visual-explainer-1.png" width="320" alt="OAuth Frame 1: The Setup">
  31. <img src="examples/05-multiframe-oauth/visual-explainer-2.png" width="320" alt="OAuth Frame 2: The Authorization Dance">
  32. <img src="examples/05-multiframe-oauth/visual-explainer-3.png" width="320" alt="OAuth Frame 3: The Complete Picture">
  33. </p>
  34. ### Presentation — Microservices Architecture
  35. Bold, minimal, conference-keynote quality — dark background with strong visual hierarchy and layered architecture.
  36. <img src="examples/06-microservices-arch/visual-explainer-1.png" width="600" alt="Presentation: Microservices">
  37. ### Mind Map — Object-Oriented Programming
  38. Vibrant, colorful, radial mind map — organic branches, bold colors, visual icons for each concept.
  39. <img src="examples/07-mindmap-oop/visual-explainer-1.png" width="600" alt="Mindmap: OOP">
  40. ### Mind Map (Structured) — Project Management Methodologies
  41. Clean, data-oriented, XMind-style — muted colors, category tags, metadata badges, professional layout.
  42. <img src="examples/08-mindmap-structured-pm/visual-explainer-1.png" width="600" alt="Mindmap Structured: PM">
  43. ### Mermaid → Infographic — API Request Lifecycle
  44. Convert a Mermaid flowchart into a polished infographic with `--from mermaid`. All nodes, edges, and labels are extracted and transformed.
  45. <img src="examples/09-mermaid-flowchart-infographic/visual-explainer-1.png" width="400" alt="Mermaid Flowchart to Infographic">
  46. <details>
  47. <summary>Source Mermaid</summary>
  48. ```mermaid
  49. flowchart TD
  50. A[User Request] --> B{Authentication}
  51. B -->|Valid Token| C[API Gateway]
  52. B -->|Invalid| D[401 Unauthorized]
  53. C --> E{Rate Limit Check}
  54. E -->|Under Limit| F[Route to Service]
  55. E -->|Over Limit| G[429 Too Many Requests]
  56. F --> H[User Service]
  57. F --> I[Order Service]
  58. F --> J[Payment Service]
  59. H --> K[(Users DB)]
  60. I --> L[(Orders DB)]
  61. J --> M[(Payments DB)]
  62. H --> N[Response Builder]
  63. I --> N
  64. J --> N
  65. N --> O[JSON Response]
  66. O --> P[Client]
  67. ```
  68. </details>
  69. ### Mermaid → Whiteboard — Login Authentication Flow
  70. Convert a Mermaid sequence diagram into a vibrant whiteboard sketch with `--from mermaid`. Actors become illustrated characters, messages become hand-drawn arrows.
  71. <img src="examples/10-mermaid-sequence-whiteboard/visual-explainer-1.png" width="600" alt="Mermaid Sequence to Whiteboard">
  72. <details>
  73. <summary>Source Mermaid</summary>
  74. ```mermaid
  75. sequenceDiagram
  76. participant U as User
  77. participant B as Browser
  78. participant S as Server
  79. participant DB as Database
  80. participant C as Cache
  81. U->>B: Fill login form
  82. B->>S: POST /api/login {email, password}
  83. S->>DB: SELECT user WHERE email=?
  84. DB-->>S: User record
  85. S->>S: Verify bcrypt hash
  86. alt Password valid
  87. S->>S: Generate JWT token
  88. S->>C: Store session {userId, token}
  89. C-->>S: OK
  90. S-->>B: 200 {token, user}
  91. B->>B: Store token in localStorage
  92. B-->>U: Redirect to dashboard
  93. else Password invalid
  94. S-->>B: 401 Invalid credentials
  95. B-->>U: Show error message
  96. end
  97. ```
  98. </details>
  99. ### Backend Comparison — How a CPU Executes an Instruction
  100. Same topic, same style, same prompt — rendered by both backends for comparison.
  101. | OpenAI (gpt-image-1.5) | Gemini (Nano Banana 2) |
  102. |---|---|
  103. | <img src="examples/11-backend-comparison/openai-cpu-whiteboard.png" width="400" alt="OpenAI: CPU Instruction Cycle"> | <img src="examples/11-backend-comparison/gemini-cpu-whiteboard.png" width="400" alt="Gemini: CPU Instruction Cycle"> |
  104. | | OpenAI | Gemini |
  105. |---|---|---|
  106. | **Dimensions** | 1536x1024 (exact) | 1024x1024 (ignores size request) |
  107. | **Text clarity** | Clean, all legible | Clean, all legible |
  108. | **Style fidelity** | Polished whiteboard texture, subtle details | Bolder colors, stronger section borders |
  109. | **Size control** | Honors exact dimensions | Always produces square output |
  110. | **Cost** | ~$0.29/image | Free tier available |
  111. Both backends produce quality results from the same prompt. OpenAI gives more control over dimensions and a more refined aesthetic. Gemini is solid and has a free tier but doesn't respect size parameters.
  112. ### Mockup — Admin Dashboard (Desktop)
  113. Polished, Figma-quality UI wireframe with `--style mockup --device desktop` — browser chrome, sidebar navigation, stats cards, charts, and data table.
  114. <img src="examples/12-mockup-dashboard/visual-explainer-1.png" width="600" alt="Mockup: Admin Dashboard">
  115. The mockup style supports three device frames (`--device mobile|desktop|tablet`) and three fidelity levels via `--draw-level`:
  116. - **sketch** — hand-drawn wireframe, great for brainstorming and design sprints
  117. - **normal** — mid-fidelity, clean enough to share with stakeholders
  118. - **polished** — Figma/Sketch-quality, pixel-perfect precision for design reviews
  119. Use cases: rapid wireframing from PRDs, brainstorming UI layouts, visualizing modernized interfaces for existing code, stakeholder alignment before opening Figma.
  120. ## Prerequisites
  121. ### 1. Claude Code
  122. Install Claude Code if you haven't already:
  123. ```bash
  124. npm install -g @anthropic-ai/claude-code
  125. ```
  126. ### 2. Image Generation API Key
  127. You need at least one of the following. If both are set, OpenAI is used by default (override with `--backend gemini`).
  128. #### Option A: OpenAI (gpt-image-1.5)
  129. 1. Go to [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
  130. 2. Create a new secret key and copy it
  131. ```bash
  132. export OPENAI_API_KEY="sk-..."
  133. ```
  134. #### Option B: Google Gemini (Nano Banana 2)
  135. 1. Go to [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
  136. 2. Create an API key and copy it
  137. ```bash
  138. export GEMINI_API_KEY="AIza..."
  139. ```
  140. #### Persist across sessions
  141. Add your key(s) to your shell profile:
  142. ```bash
  143. # For zsh (~/.zshrc)
  144. echo 'export OPENAI_API_KEY="sk-..."' >> ~/.zshrc
  145. echo 'export GEMINI_API_KEY="AIza..."' >> ~/.zshrc
  146. source ~/.zshrc
  147. # For bash (~/.bashrc or ~/.bash_profile)
  148. echo 'export OPENAI_API_KEY="sk-..."' >> ~/.bashrc
  149. echo 'export GEMINI_API_KEY="AIza..."' >> ~/.bashrc
  150. source ~/.bashrc
  151. ```
  152. ### 3. jq
  153. The skill uses `jq` to parse JSON responses from the API:
  154. ```bash
  155. # macOS
  156. brew install jq
  157. # Ubuntu/Debian
  158. sudo apt-get install jq
  159. ```
  160. ## Compatibility
  161. This skill was primarily developed and tested with **Claude Code**, but it should work with any Skills-compatible agent or CLI tool that supports markdown skill definitions, including:
  162. - **[Claude Code](https://claude.ai/code)** (primary target)
  163. - **[OpenClaw](https://github.com/ericblue/openclaw)** (tested)
  164. - Any agent that reads `.md` skill files with YAML frontmatter
  165. The skill is a self-contained markdown file with structured instructions. Any agent that can parse the frontmatter, read the step-by-step instructions, and execute shell commands (curl, jq, base64) can run it.
  166. ## Installation
  167. ### Claude Code
  168. ```bash
  169. git clone <repo-url> && cd visual-explainer-skill
  170. make install
  171. ```
  172. Or manually:
  173. ```bash
  174. cp skill/visual-explainer.md ~/.claude/commands/visual-explainer.md
  175. ```
  176. The skill will be available immediately as `/visual-explainer` in any Claude Code session.
  177. ### OpenClaw
  178. ```bash
  179. make openclaw-install
  180. ```
  181. Or manually:
  182. ```bash
  183. mkdir -p ~/clawd/skills/visual-explainer
  184. cp skill/visual-explainer.md ~/clawd/skills/visual-explainer/SKILL.md
  185. ```
  186. ### Makefile targets
  187. | Target | Description |
  188. |--------|-------------|
  189. | **Claude Code** | |
  190. | `make install` | Install to `~/.claude/commands/` |
  191. | `make uninstall` | Remove from `~/.claude/commands/` |
  192. | **OpenClaw** | |
  193. | `make openclaw-install` | Install to `~/clawd/skills/` |
  194. | `make openclaw-uninstall` | Remove from `~/clawd/skills/` |
  195. | `make openclaw-check` | Check install status |
  196. | **General** | |
  197. | `make info` | Show skill name, version, author, and available styles |
  198. | `make version` | Print the current version |
  199. | `make check` | Verify prerequisites (jq, skill files, OPENAI_API_KEY) |
  200. ## Usage
  201. ```
  202. /visual-explainer [--style S] [--draw-level L] [--complexity C] [--size WxH] [--mode M] [--output DIR] [--prefix NAME] <content>
  203. ```
  204. ### Quick examples
  205. ```bash
  206. # Default whiteboard style
  207. /visual-explainer How DNS resolution works
  208. # Professional infographic
  209. /visual-explainer --style infographic The foundations of machine learning
  210. # Rough sketch feel
  211. /visual-explainer --draw-level sketch How Git branching works
  212. # Detailed technical diagram
  213. /visual-explainer --style diagram --complexity detailed Kubernetes pod networking
  214. # Multi-frame progressive build-up
  215. /visual-explainer --mode multi-frame The OAuth2 authorization code flow
  216. # Custom output location
  217. /visual-explainer --output ./docs/images --prefix arch-overview System architecture of a microservices app
  218. # Colorful radial mind map
  219. /visual-explainer --style mindmap The principles of object-oriented programming
  220. # Clean, data-oriented XMind-style mind map
  221. /visual-explainer --style mindmap-structured Project management methodologies
  222. # UI wireframe mockup (mobile, polished by default)
  223. /visual-explainer --style mockup A mobile app login screen with email, password, social login, and forgot password
  224. # Desktop web app wireframe
  225. /visual-explainer --style mockup --device desktop An admin dashboard with sidebar nav, stats cards, charts, and data table
  226. # Hand-drawn wireframe for brainstorming
  227. /visual-explainer --style mockup --draw-level sketch A settings page with profile photo, name fields, toggles, and save button
  228. # Use Gemini instead of OpenAI
  229. /visual-explainer --backend gemini How the water cycle works
  230. ```
  231. ### Converting Mermaid diagrams
  232. Any Mermaid diagram can be transformed into any visual style. The skill parses nodes, edges, subgraphs, and labels to build a detailed visual prompt.
  233. ```bash
  234. # Inline Mermaid — paste or type the diagram as the content
  235. /visual-explainer --style infographic --from mermaid flowchart TD; A[Start] --> B{Decision}; B -->|Yes| C[Do Thing]; B -->|No| D[Other Thing]
  236. # From a .mmd file
  237. /visual-explainer --style whiteboard --from mermaid-file docs/architecture.mmd
  238. # From a markdown file containing a mermaid code block
  239. /visual-explainer --style presentation --from mermaid-file docs/sequence-diagram.md
  240. # Auto-detect — if the content looks like Mermaid, it's parsed automatically
  241. /visual-explainer --style diagram sequenceDiagram; participant A as Client; participant B as Server; A->>B: Request; B-->>A: Response
  242. ```
  243. ### Working with existing documents
  244. The skill works great when pointed at existing files. You can ask it to read a document, summarize the key concepts, and generate a visual from it.
  245. **Generate directly from a file:**
  246. ```
  247. Read docs/architecture.md and then /visual-explainer --style diagram the system architecture described in that document
  248. ```
  249. **Summarize first, then visualize:**
  250. ```
  251. Read docs/api-spec.md, summarize the key endpoints, request/response flows, and auth
  252. mechanisms, then /visual-explainer --style infographic the summary
  253. ```
  254. **Visualize a README or spec:**
  255. ```
  256. Review the PRD at docs/product-requirements.md and /visual-explainer --style presentation
  257. a one-slide executive summary of the product vision, key features, and target users
  258. ```
  259. **Turn meeting notes into a whiteboard:**
  260. ```
  261. Read notes/2024-03-15-retro.md and /visual-explainer --draw-level sketch
  262. a whiteboard summary of the key takeaways, action items, and themes
  263. ```
  264. **Compare concepts from a doc:**
  265. ```
  266. Read docs/database-comparison.md and /visual-explainer --style infographic --complexity detailed
  267. a comparison of the database options with pros, cons, and recommendations
  268. ```
  269. **Multi-frame walkthrough of a complex doc:**
  270. ```
  271. Read docs/deployment-guide.md and /visual-explainer --mode multi-frame --style whiteboard
  272. the deployment process as a step-by-step walkthrough
  273. ```
  274. **Visualize code architecture:**
  275. ```
  276. Review the src/ directory structure and key modules, then /visual-explainer --style diagram
  277. --complexity detailed the codebase architecture showing module dependencies and data flow
  278. ```
  279. ### Options
  280. | Option | Values | Default | Description |
  281. |--------|--------|---------|-------------|
  282. | `--style` | `whiteboard`, `infographic`, `presentation`, `diagram`, `mindmap`, `mindmap-structured`, `mockup` | `whiteboard` | Visual style |
  283. | `--device` | `mobile`, `desktop`, `tablet` | `mobile` | Device frame for mockup style |
  284. | `--draw-level` | `sketch`, `normal`, `polished` | `normal` | Hand-drawn roughness vs clean precision |
  285. | `--complexity` | `simple`, `moderate`, `detailed` | `moderate` | Number of concepts (3-4, 5-7, or 8-12) |
  286. | `--size` | `1024x1024`, `1536x1024`, `1024x1536` | Style-dependent | Image dimensions |
  287. | `--mode` | `single`, `multi-frame` | `single` | One image or a progressive series |
  288. | `--from` | `mermaid`, `mermaid-file PATH` | (none) | Parse Mermaid input (inline or from a file) |
  289. | `--backend` | `openai`, `gemini` | Auto-detected | Image generation backend. Auto-detects based on available API keys. |
  290. | `--output` | Directory path | `./` | Where to save generated images |
  291. | `--prefix` | String | `visual-explainer` | Filename prefix |
  292. ### Default sizes by style
  293. | Style | Default Size | Orientation |
  294. |-------|-------------|-------------|
  295. | Whiteboard | 1536x1024 | Landscape |
  296. | Infographic | 1024x1536 | Portrait |
  297. | Presentation | 1536x1024 | Landscape |
  298. | Diagram | 1024x1024 | Square |
  299. | Mind Map | 1536x1024 | Landscape |
  300. | Mind Map (Structured) | 1536x1024 | Landscape |
  301. | Mockup (mobile/tablet) | 1024x1536 | Portrait |
  302. | Mockup (desktop) | 1536x1024 | Landscape |
  303. ## How It Works
  304. 1. **Backend detection** — Auto-detects available API keys (OpenAI or Gemini) and reports which backend will be used
  305. 2. **Content analysis** — The skill deeply analyzes your input to extract core concepts, sub-topics, relationships, visual metaphors, and an optimal layout strategy
  306. 3. **Prompt construction** — A detailed 400-800 word prompt is built using style-specific templates that specify exact spatial positions, icons, colors, typography, connections, and decorative elements
  307. 4. **Image generation** — The prompt is sent to OpenAI gpt-image-1.5 or Gemini Nano Banana 2
  308. 5. **Structured output** — A text summary of sections, relationships, and backend used is provided alongside the image
  309. ## Cost
  310. ### OpenAI (gpt-image-1.5)
  311. | Size | Estimated Cost |
  312. |------|---------------|
  313. | 1024x1024 | ~$0.19 |
  314. | 1536x1024 / 1024x1536 | ~$0.29 |
  315. ### Gemini (Nano Banana 2)
  316. Free tier available. Check current pricing at [aistudio.google.com](https://aistudio.google.com/).
  317. Multi-frame mode generates multiple images (3-5), so costs multiply accordingly.
  318. ## Tips
  319. - **Text-heavy content** works best with `infographic` style
  320. - **Process/flow content** works best with `diagram` style
  321. - **Engaging/fun explanations** work best with `whiteboard` style
  322. - **Hierarchical/categorical content** works best with `mindmap` (colorful) or `mindmap-structured` (data-oriented)
  323. - Use `mindmap` when the audience values visual appeal and creativity
  324. - Use `mindmap-structured` for board presentations, strategy docs, or data-heavy taxonomies
  325. - **UI wireframes and screen layouts** work best with `mockup` style — use `--device` to match the target platform
  326. - Use `mockup --draw-level sketch` for early brainstorming, `--draw-level polished` for stakeholder-ready wireframes
  327. - Use `--draw-level sketch` for a casual, brainstormy feel
  328. - Use `--draw-level polished` for clean hand-lettering on whiteboard style
  329. - Use `--complexity detailed` when you need comprehensive coverage
  330. - If results feel too sparse, try increasing complexity; if too cluttered, decrease it
  331. ## Version History
  332. | Version | Date | Description |
  333. |---------|------|-------------|
  334. | 1.3.0 | 2026-04-02 | Mockup/wireframe style with device frames |
  335. | 1.2.0 | 2026-04-02 | Gemini/Nano Banana 2 backend support |
  336. | 1.1.0 | 2026-04-01 | Mermaid diagram conversion support |
  337. | 1.0.0 | 2026-04-01 | Initial release |
  338. ### v1.3.0 — Mockup/Wireframe Style
  339. - New `mockup` style for generating UI wireframes and screen mockups
  340. - `--device` flag to select device frame: `mobile` (phone), `desktop` (browser window), `tablet` (iPad-style)
  341. - Three fidelity levels via `--draw-level`: sketch (hand-drawn), normal (mid-fi), polished (Figma-quality)
  342. - Comprehensive prompt template with support for navigation, input fields, buttons, cards, tables, charts, and all standard UI components
  343. - Annotation support for wireframe callouts and specifications
  344. - Ideal for rapid wireframing from PRDs, brainstorming UI layouts, and visualizing modernized interfaces
  345. ### v1.2.0 — Gemini Backend Support
  346. - `--backend` flag to choose between `openai` (gpt-image-1.5) and `gemini` (Nano Banana 2)
  347. - Auto-detection: uses whichever API key is available; defaults to OpenAI if both are set
  348. - Backend reported before generation and in structured output summary
  349. - Gemini API integration via `generativelanguage.googleapis.com`
  350. - Size handling adapted for Gemini (dimensions included in prompt text)
  351. - Updated prerequisites to support either `OPENAI_API_KEY` or `GEMINI_API_KEY`
  352. ### v1.1.0 — Mermaid Diagram Conversion
  353. - `--from mermaid` flag for inline Mermaid input
  354. - `--from mermaid-file PATH` for reading `.mmd` or `.md` files
  355. - Auto-detection of Mermaid syntax in content
  356. - Full parsing of all Mermaid diagram types: flowchart, sequence, class, state, ER, gantt, pie, mindmap, timeline
  357. - Extracts nodes, edges, subgraphs, participants, attributes, and labels for precise prompt construction
  358. - Any Mermaid diagram type can be rendered in any visual style
  359. ### v1.0.0 — Initial Release
  360. - 6 visual styles at launch: whiteboard, infographic, presentation, diagram, mindmap, mindmap-structured
  361. - `--draw-level` parameter (sketch, normal, polished) for hand-drawn vs professional spectrum
  362. - `--complexity` parameter (simple, moderate, detailed) for content density control
  363. - `--mode multi-frame` for progressive build-up explanations
  364. - Deep content analysis pipeline with concept extraction, visual metaphors, and layout strategy
  365. - Style-specific prompt templates (400-800 words) for each visual style
  366. - Integration with OpenAI gpt-image-1.5 via generate-images skill
  367. - YAML frontmatter with official Claude Code skill metadata
  368. - Makefile with install, uninstall, version management, and release targets
  369. - 8 example images across all styles
  370. ## License
  371. MIT — see [LICENSE](LICENSE) for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.