Skip to content
Skills Library
Programming · Learning & explanation

visualize

/visualize

Draw the thing under discussion — the real shape, from the real code, anchored to file:line. Use when the user asks to visualize code, architecture, or a flow; use verify-responsive to check a running UI at a viewport width.

Repository
greybeard ↗
Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Draw the thing under discussion — the real shape, from the real code, anchored to file:line. Use when the user asks to visualize code, architecture, or a flow; use verify-responsive to check a running UI at a viewport width.

Arguments

/visualize [what to visualize — optional]
Original author description

Draw the thing under discussion — the real shape, from the real code, anchored to file:line. Use when the user asks to visualize code, architecture, or a flow; use verify-responsive to check a running UI at a viewport width.

How it works

SKILL.md has no level-two headings · 111 lines, 925 words

SKILL.md preview
---
name: visualize
description: "Draw the thing under discussion — the real shape, from the real code, anchored to file:line. Use when the user asks to visualize code, architecture, or a flow; use verify-responsive to check a running UI at a viewport width."
argument-hint: [what to visualize — optional]
---

The optional input is the text supplied with this skill invocation, through a slash command or a plain-language request. If none was supplied, follow the no-input behavior below.

Show me **the supplied input** visually — or, if that's empty, whatever is currently on the table in this conversation. Skip the preamble, keep the prose short, and pick the *smallest* view that makes the point.

**Draw what's there, not what you'd expect to be there.** A diagram launders a guess better than prose ever could: boxes and arrows read as *verified* even when nobody opened the file. Prose hedges out loud ("it probably calls…"); a flowchart just asserts. That makes an ungrounded visual the most expensive thing you can hand someone — they'll build on it for weeks.

So, before drawing:

- **Read the code you're about to draw.** The actual files, in this repo, this session — not the neighbors, not the pattern this framework "usually" follows, not a version of it you remember. If the diagram has five nodes, you opened five things.
- **Anchor every node.** Participants, boxes, tree entries, and call-stack frames name a real `path/to/file.ts:42`. A node you can't anchor is a node you didn't verify.
- **Tag what you didn't open — `ASSUMED`.** Sometimes a branch matters to the shape but you haven't read it (an upstream SDK, a path that's out of scope). Draw it, mark it `ASSUMED`, and say what would confirm it. Never quietly complete the picture; a diagram that's 90% verified and 10% invented, unmarked, is 100% untrustworthy.
- **Draw the current shape before the proposed one — and trace it with the real input.** If the point is a change, the "before" side comes from the code as it is today, not as you'd have written it. An anchor proves the node exists; it does not prove the arrow fires. Before drawing a current shape for input X, carry X itself through every lookup, guard, and branch on the path — the registry has that key, the config applies to it, the early return isn't taken. If the trace dead-ends, the dead end *is* the current shape: draw the failure, not the flow you expected. And a node whose annotation contradicts the diagram's own conclusion is a node you haven't reconciled — resolve it or prune it before shipping the picture.

### Forms

Use one, sometimes a few, rarely all. Match the form to the question being asked — **and to the surface it lands on.**

**Check the surface before you pick.** A terminal has no diagram renderer: a `mermaid` fence there prints its own source code, which is strictly worse than the plain-text form it replaced. So in a terminal (Claude Code, a shell, a plain log) every form below must be *text that is already the picture* — trees, indentation, box-drawing characters. Reach for Mermaid only when the output lands somewhere that actually renders it: a published artifact, a `.md` file read on GitHub, the desktop or web app. When in doubt, assume it won't render and draw it as text.

- **Logic or an algorithm** — pseudocode:

  ```text
  on(save)
    if content is unchanged
      return cached result
    write new content
    return fresh result
  ```

- **Runtime control flow** — a call tree:

  ```text
  submitForm            app/form.tsx:88
    createSession       lib/session.ts:12
      persistPrompt     lib/session.ts:31
      launchAgent       lib/agent.ts:104
    navigateToSession   app/form.tsx:96
  ```

- **UI structure** — a component tree, with the state and module boundaries that matter:

  ```tsx
  <SessionPage>                    apps/example/src/routes/session.tsx
    useSessionEvents()             hooks/use-session-events.ts:9
    <SessionToolbar>
      <RunSkillButton>             packages/ui/src/run-skill-button.tsx
  ```

- **File responsibility, or a broad refactor** — a shallow file tree:

  ```text
  src/
  ├── commands/       # parses user actions
  ├── sessions/       # owns session state
  └── transport/      # sends API requests
  ```

- **Component interaction, or data flow between processes** — a text sequence, drawn with box-drawing characters. This is the terminal-safe form:

  ```text
  form.tsx:88              daemon.ts:210
       │                         │
       │── send expanded prompt ▶│
       │                         │── spawn agent   agent.ts:41
       │◀──── stream result ─────│
  ```

  Same shape as Mermaid, no renderer required. **Only** if the output lands on a surface that renders diagrams (a published artifact, a `.md` on GitHub) is the `mermaid` fence the better call:

  ```mermaid
  sequenceDiagram
      participant UI as form.tsx:88
      participant D as daemon.ts:210
      UI->>D: send expanded prompt
      D-->>UI: stream result
  ```

- **What changes**, when the surrounding shape already exists — a `diff`, shaped like whatever the topic is (component tree, file layout, call stack, control flow):

  ```diff
   src/
   ├── commands/
  +│   └── visualize.ts     # expands the slash command
   ├── sessions/
  -└── transport.ts
  +└── transport/
  +    ├── client.ts
  +    └── stream.ts
  ```

- **The whole block**, when most of it is new, when omitted context would hide ownership or order, or when I need a copyable target shape:

  ```ts
  function expandCommand(command: string): string {
    return `use the ${command.slice(1)} skill`;
  }
  ```

- **One focused HTML file** — for a visual UI, a layout, a state comparison, or a concept too dense for Mermaid: a diagram, an infographic, or a short slide deck, whichever fits. Match the product's real colors, type, spacing, and components; use real labels and real data. Then open it:

  ```
  Bash(open path/to/visualize-{description}.html)
  ```

### Guidance

Place each visual next to the short text it supports. Keep only the calls, files, props, states, and boundaries needed to answer the question actually being asked — an exhaustive diagram is a refusal to decide what matters. Prune every node that doesn't earn its place, then say what you left out.

Close with the anchors: the `file:line` list behind the drawing, and any `ASSUMED` node with the one check that would settle it.

Versions

RepositoryScoreLicence
This page · clawnify/greybeard100MIT
cloudgeni-ai/opengeni100Apache-2.0
asgeirtj/system_prompts_leaks100CC0-1.0
amit429/understanding-map100MIT
asgeirtj/system_prompts_leaks100CC0-1.0
nathanvale/side-quest-marketplace100MIT
HaizhuAI/Zkali100Apache-2.0
vellum-ai/vellum-assistant100MIT
borayil/fosset100MIT

Database snapshot: 13.11.2026 · package version b759899e1068 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90cmk:visualize
    Use when the user asks to "visualize this repo", "map this codebase", "draw the architecture", "show me how this fits together", or wants a diagram of a system traced from its real code. Produces a validated scene graph and renders it as an interactive isometric map or a static…
  • 90explain-code
    Explain how a piece of code works (a function, file, module, or a flow like "what happens when a user signs up") with file and line references, traced from the actual code. Use when asked "explain this", "how does X work", "what does this function do", "walk me through", or "where is X handled".
  • 100architecture-diagram
    This skill should be used when the user asks to "create a diagram", "make an architecture diagram", "design a system diagram", "draw an architecture", "create a technical diagram", "make a deployment diagram", "visualize infrastructure", "create a data flow diagram", "draw…
  • 90flowlens
    Generate, regenerate or open an interactive HTML flow map of the current repository with FlowLens (API calls, data flow, module dependencies, agent handoffs, with file and line evidence), or change what it scans. Use when the user asks to map, visualize or explain how the…
  • 100loc-diagram
    Use when the user asks how something in the project works or flows ("how does saving an entry work", "jak dziala zapis wpisu", "show the flow of X", "skad sie bierze Y", "co sie dzieje po Z", "loc-diagram <topic>"), and for "loc-diagram overview" at the end of a plan. Draws a…
  • 100mermaid-diagramming
    Create Mermaid diagrams using the project's blue-gray theme. Use whenever the user asks to draw a diagram, create a flowchart, visualize a process, document architecture, or add any Mermaid diagram to a markdown file. Trigger on phrases like "draw a diagram", "create a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.