Anatomy skill

A skill that draws interactive isometric illustrations in SVG, with WebGL shaders and React output, explaining an idea as a working machine

  • 22,392 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • The agent runs Node scripts and headless Chrome, and `drive.mjs` executes JavaScript it is given
  • The skill writes build scripts, pages and screenshots into the project
  • Publishing to the community gallery goes through the GitHub CLI and opens a pull request from your account, but only after your consent
All reasons and checks

wheresryan22/anatomy

Install

Manual install

npx skills add wheresryan22/anatomy -g -a claude-code

Installs the skill into ~/.claude/skills/anatomy. Version 1.7.1 of the skills CLI asks for Node.js 22.20 or newer. Without -g the skill goes into the current project.

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The agent runs Node scripts and headless Chrome, and `drive.mjs` executes JavaScript it is given
  • The skill writes build scripts, pages and screenshots into the project
  • Publishing to the community gallery goes through the GitHub CLI and opens a pull request from your account, but only after your consent

This is third-party code. Review the repository files before installing.

What it does

Anatomy is a skill for isometric SVG illustrations. You name an idea, for example how a cache works, and the agent invents a physical object whose working matches that idea. A cache key that skips needless work becomes a pin-tumbler lock that turns only when every pin matches. The object is assembled from dozens of small parts, and the numbers on its readout come from the same small model that moves the parts. SKILL.md sets the order of work: collect the true numbers, invent the object, write a parts list (40 or more for a small figure), choose the camera, build the geometry once with the library in the kit folder, paint the parts back to front, and frame the drawing in a card with a title, a hint and a live readout. At the end the agent checks its own work: scripts open the page in headless Chrome and take screenshots and close-ups, and `kit/audit.mjs` proves that no part passes through another. The result is source files in your project: a Node build script with a ready HTML page, a standalone `.svg` file with embedded styles, or components for React and Next.js. For fire, exhaust, water and lamp light a WebGL shader is added; it renders between two SVG layers in the same isometric camera. The true 3D mode, where parts rotate, is called beta by the author.

Who it is for. For developers, technical writers and designers who need an illustration for docs, an article or a landing page and are fine receiving it as code.

Good fit when

  • An article or docs page needs an illustration that explains an algorithm, a cache, a queue or a connection pool through a machine rather than a flowchart with arrows
  • A landing page needs an isometric picture that moves smoothly under the pointer and responds to the keyboard
  • The result must land in your project as an HTML page, a standalone `.svg` file or a React or Next.js component, in a light or dark theme
  • The drawing needs fire, exhaust, water, caustics or lamp light: a WebGL layer is built into the same isometric view

Not a fit when

  • You need charts with axes and data series: Anatomy is not a chart library, and the numbers come from the figure's own model
  • You need people or exact maps: the skill draws machines, instruments, tools and furniture, and an idea without a mechanism comes out weaker
  • You need a plain architecture diagram or flowchart: the Diagram Design skill is simpler for that
  • You need a result in a few minutes: a figure is built in a long session, and the author estimates a dense piece at 2–4 hours
  • The environment has no Node.js 20.10 or newer: the build and checks rely only on Node's built-in modules

Example request

Draw an interactive isometric illustration of how a token bucket rate limiter works, light theme, a single HTML file

Limitations

  • The check scripts start Chrome or Chromium headless with a temporary profile and the `--allow-file-access-from-files` flag, and `drive.mjs` runs JavaScript it is given. Point them only at pages you trust.
  • In the Codex sandbox, starting Chrome may be blocked: the figure is still built, but the checks fail. The author suggests approving the command on request, editing `~/.codex/config.toml` or running the check in a normal terminal.
  • The 3D mode is beta: it is proved on one example and one test figure. A small figure runs at 60 frames per second, a 380-part hand at about 20 on a 1440 px wide screen.
  • A full 3D orbit audit takes 15–20 minutes for 30 parts, and building the Raptor engine example takes a few minutes. Installing the skill copies the whole repository with examples, about 10 MB.
  • Shaders need WebGL: without it the SVG still reads, and with reduced motion on every figure holds still.

How to disable. Delete the skill folder: `~/.claude/skills/anatomy` for Claude Code, `~/.agents/skills/anatomy` for Codex, `~/.config/opencode/skills/anatomy` for OpenCode. For a single-project install the folder sits in `.claude/skills/anatomy` or `.agents/skills/anatomy`. Finished figures stay in the project as plain files, because the drawing kit ships with them.

FAQ

How do I make an isometric SVG illustration with an AI agent?

Install Anatomy and invoke `/anatomy` with the idea. The author recommends three habits: name the idea itself without describing the drawing, give real numbers (sizes, counts, thresholds) and say where the figure will live: an HTML page, an `.svg` file or a React component, in a light or dark theme.

Does Anatomy need API keys or third-party packages?

No. The kit uses only Node's built-in modules and there is nothing to install through npm. React 18 or newer is needed only for the ready components in `kit/react/`.

Which agents run Anatomy besides Claude Code?

The skill is written for Claude Code and follows the open Agent Skills format, so Antigravity, OpenCode, Codex and MiniMax Code load it too. In Codex it is invoked as `$anatomy`, in the others as `/anatomy`.

Can I get the illustration as a React or Next.js component?

Yes. A figure arrives as geometry modules, a server component for the static art and one client component for the motion. The `test-rig` and `spot-plate` examples ship without a build script: you copy them into a React app.

How does Anatomy check that no part passes through another?

A build with the `--audit` flag runs `kit/audit.mjs`: it verifies that pipes and cables do not cross other parts, every end sits on a mount and overlaps are drawn in the right depth order. The `scripts/lines.mjs` script separately catches lines that end in mid-air.

How do I publish a figure to the Anatomy community gallery?

Ask the agent to publish the figure. It asks for a title, your GitHub name and a license (MIT or CC-BY-4.0), shows the plan and, after your yes, opens a pull request in the anatomy-community repository. React figures are not accepted, and the gallery rejects network calls and `eval`.

Discussion

No questions or reviews yet.

Skills

A skill rebuilds the object in a reference image as a procedural Three.js model written in code, not downloaded art

SkillMinimal access19.7KRepository stars

Twelve skills that make an agent build single-file HTML animations: slides, protocol diagrams, architecture diagrams and demos for screen recording

SkillExtended access1.7KRepository stars

A skill that turns your photo or description into a hand-drawn character and uses it for diagrams, knowledge cards and slides

SkillExtended access263Repository stars

A Claude skill for Spine 2D animation: it positions character parts, builds the skeleton JSON and prepares an HTML preview

SkillExtended access609Repository stars

A skill that takes an agent from a generated picture to a game asset: sprites, video-to-frames animation and pre-release checks

SkillExtended access306Repository stars

A Claude Code skill for short animated videos drawn in code: seven styles, story and storyboard sign-off, voice-over and an MP4 render

SkillExtended access1.1KRepository stars

Comparison with similar tools

Entries that share the main search query, and how they differ.

EntryOfficialRepository starsMain difference
Anatomy (this entry)no22,392
Diagram Designno62,457draws editorial HTML and SVG diagrams of about forty types: architecture, flowcharts, ER, funnels
Architecture Diagram Generatorno7,504builds one system architecture diagram in an HTML file with PNG and PDF export buttons

README in short

The repository holds SKILL.md with the working order, a `kit/` folder with the drawing library, a `references/` folder with long guides, check scripts, eight finished examples with built pages, test prompts in `evals/evals.json` and CI settings. The front page shows a gallery, a table of three kinds of figure (SVG, SVG with WebGL and 3D), install routes for five agents and a section on limits.

README badge

Original SKILL.md

---
name: anatomy
description: Build crafted, highly detailed, interactive isometric SVG figures that explain a technical idea as a real physical object (a test rig, a dial gauge, a cabinet of drawers, a plotter, a lock), with many small precise solid parts, four-tone shading, correct painter's order, a framed card with title, hint and live readout, and calm eased motion. Use this whenever someone wants an isometric illustration, an explanatory diagram or figure for docs, a blog post, a landing page or an article, a "Linear-style" or "premium" technical drawing, an interactive explainer, or an SVG that shows how a system, algorithm or component works, even if they never say "isometric". Works framework-free (TypeScript/JS that writes SVG and HTML) and in React/Next.js, and can add realistic WebGL shaders (fire, exhaust, water, caustics, lamp light) that live inside the drawing in the same isometric perspective. Also publishes a finished figure to the Anatomy community gallery when asked.
license: MIT
compatibility: Written for Claude Code; also runs in Antigravity, OpenCode, Codex and MiniMax Code. Needs Node.js 20.10+, and Chrome or Chromium for the checks.
metadata:
  opencode/slash: "true"
---

# Anatomy

This skill makes figures like a small instrument on a bench: a heavy base on feet, rails with tick rulers, a carriage on bushings, knurled knobs, coil springs, a dial gauge whose needle moves, screws as tiny dots. The reader understands the idea because they recognise the machine. Every number the figure shows comes from the same model that moves its parts.

Eight complete examples ship with the skill. Open the closest one before you start. Each framework-free example is built with `node examples/<name>/build.mjs`, which writes a standalone HTML page next to the script; add `--light` for the light theme.

- `examples/dial-indicator/` is the smallest: a dial gauge on a stand, about 300 lines in all.
- `examples/desk-computer/` is framework-free SVG: a desk computer with a keyboard you can type on. The typed line appears on a CRT screen drawn in the plane of the case front, and the picture collapses to a line and a dot when you switch it off. It has about 85 solids and 850 paths.
- `examples/arcade-cabinet/` is an upright arcade cabinet with its side panel off, a Hero of about 240 solids and 15 cables. A quarter flies into the slot, rolls down the coin chute at the speed a rolling disc reaches on a 30° slope, trips the coin-switch wire and drops into the cash box; the switch's pulse runs chunk by chunk along its cable to the board, and the CRT warms up, self-tests and runs an attract mode drawn in the plane of the tilted monitor. The stick tilts and closes a microswitch under the panel. It shows how to place a camera so a cutaway's mechanism stays in view, a concave board drawn as a prism along any axis, moving parts rebuilt in the page from the same module the build uses, and live coins and a wire drawn in reserved slots of the settled order. `node build.mjs --audit` proves the geometry.
- `examples/raptor-engine/` is a rocket engine hanging in a test stand. Its round parts come from `kit/lathe.mjs` and its pipes and harness from `kit/tube.mjs`. It comes apart into 11 assemblies with staggered springs and per-frame depth re-sorting. Every part records its true shape, and `node build.mjs --audit` (`kit/audit.mjs`) proves, at rest, apart and in every replayed frame of the explode, that nothing passes through anything, that every end sits on a real mount, that no bend pinches, folds or lands on another line, that no curved profile's slope wobbles, and that every overlap is drawn in depth order. A WebGL plume, shock, splash and steam render between the back and front SVG. It is the reference for dense pipework, smooth shading and fades.
- `examples/ripple-tank/` is a school ripple tank on tall legs over a paper screen, seen from 44° up. Two WebGL layers (lamp light, shadows and caustics on the paper, and the water's reflections and glass) are registered to the isometric planes and driven by a pure dispersion and optics model (`model.mjs`); a frequency change travels out from the dippers through a history texture.
- `examples/test-rig/` is a production figure from a real site (React/Next): a glass button on a spring-mounted carriage, a finger probe on a rail that presses and pulls, and a dial gauge reading the lean. It has 53 solids and about 470 paths.
- `examples/spot-plate/` is a second production figure from the same site: six pairs of glass drops on a spot plate, each pair drawn from one distance field, so a pair closer than `merge` runs together into one piece of glass. A fan of feeler blades sets `merge`, one blade per gap. It is the reference for shapes that morph into each other and for one control driving many parts.
- `examples/turning-dial/` is the optional 3D mode: a combination dial that turns in true 3D with a small robot hand on it. It has about 90 live parts in metal materials, a second turn group, a hinge, a three-hinge finger that lifts and a pod that breaks off as a free body. A WebGL LED, its light pool and sparks follow the moving parts. `stress.mjs` beside it is a dense hand of about 380 parts in a cluttered workshop, used to measure performance.

The test rig is the quality bar for the drawing itself. The Raptor is the bar for shader work: a WebGL effect has to reach its standard of world-space, no-pop, seamless rendering.

## The one idea that matters

**The object is the explanation.** Don't draw boxes, arrows and labels. Invent a real, well-made physical thing whose working *is* the concept. Here is how earlier figures mapped:

Report a problem

Foxx AIAnatomy
Foxx AI

I am Foxx AI and I have already vetted this tool. Ask about install, setup or anything else, and I will keep it simple.