Claude Draws the Machine, Then Audits Its Own Geometry

Most attempts to make LLMs draw explanatory diagrams end in the same place: boxes, arrows, and a label or two, rendered with the confidence of a consultant and the physical intuition of none. Anatomy, a Claude skill by Ryan (wheresryan22), takes a different bet. When you ask it to explain an idea, it doesn’t draw a diagram of the concept. It invents a physical machine whose working is the concept, builds that machine out of dozens of small shaded parts, makes it move, and then — this is the unusual part — checks its own drawing for geometric impossibilities before handing it over.

A cache key that skips work when nothing changed becomes a pin-tumbler lock that only turns when every pin matches. One GPU context serving many canvases becomes a gantry plotter whose single print head visits sixteen wells. A token bucket rate limiter becomes… presumably a bucket, with a tap and a drain, arranged so that the arithmetic is visible in brass and glass. The metaphor isn’t decoration; it’s the explanation. If the lock can turn when a pin is wrong, the figure has lied, and the skill is built around making sure it doesn’t.

The premise: mechanism as pedagogy

The core insight is old — it’s the insight behind every cutaway drawing in a mid-century encyclopedia and every isometric illustration tool that lets you drag furniture onto a grid. People understand systems better when they can see a working object than when they can read a data-flow chart. What’s new is who does the authoring.

Until recently, interactive explanatory graphics were human labor, and expensive human labor at that. The Flourish interactive SVG template is representative of the state of the art for non-engineers: you prepare your SVG in Illustrator or Figma, give every element a unique ID, upload it, and wire up clickable regions to panels of content. The tooling handles the interactivity; the drawing, the grouping, the anatomical correctness — that’s on you. A recent job posting for an educational platform spells it out: a frontend developer wanted to hand-build clickable SVG files of the human skeleton, each bone a separate path with its own ID, anatomically correct, “not artistic.” That is a week of careful, tedious work per skeleton.

Anatomy is a wager that an agent can do that authoring end-to-end — and not just annotate a drawing a human made, but invent the object, plan its parts, and verify the result. The skill’s own framing is that naming the idea, not the drawing, is the right prompt shape: you say what should be explained and give the real numbers, and the agent does the invention. That inverting of the brief — “explain connection pooling, ten connections, a queue” rather than “draw a cylinder with ten dots” — is where most of the work lives, and the README is candid that the agent does that part better than a human description of boxes and arrows would.

The boring part is where the value is

Strip away the rhetoric and Anatomy is a drawing library plus a very long instruction file. The skill ships a kit: an isometric camera, a solids and parts library, round parts on any axis, pipes and cables, a WebGL layer, a 3D runtime, and React components. It has zero dependencies — Node’s built-in modules only — which sounds like a lifestyle choice until you realize what it buys: the agent can build a figure in a sandboxed environment with no npm install, no API keys, no network. The output is source you own: a Node build script and the page it writes, or geometry modules and React components for a Next.js site. Nothing is a black box.

The craft rules are the interesting constraint. Parts are painted back to front in a fixed isometric camera, with four-tone shading, so the drawing reads as solid objects rather than flat shapes. Figures ship as standalone HTML, a lone SVG file with styles embedded, or React components. Where lines can’t draw something — fire, exhaust, water, caustics — a WebGL shader runs in a canvas sandwiched between a back and a front SVG layer, registered to the same isometric camera so the plume sits inside the drawing rather than floating over it. And the SVG still reads without WebGL, which is the kind of graceful degradation that separates figures meant for documentation from demos meant for a conference stage.

The examples give a sense of the ceiling. A dial indicator gauge, at about 300 lines, is the smallest. A 1984-style desk computer with a typable keyboard and a CRT that collapses to a line and a dot when switched off, at roughly 85 solids. An arcade cabinet with about 240 solids and 15 cables, where dropping a quarter sends it rolling down the coin chute, past the switch wire, into the cash box, and the CRT warms up into an attract mode. And the reference piece: a Raptor 2 engine in a test stand that comes apart into 11 assemblies on hover, with a shader-drawn exhaust plume — a build the README says takes a few minutes. Two of the examples are described as production figures from a real React site, which is the strongest evidence in the repo that this survives contact with actual documentation work.

The agent as its own critic

Here is the part that genuinely distinguishes Anatomy from “prompt the model until the SVG looks right.” The skill has a verification loop, and the loop is mechanical, not vibes.

A geometry audit proves that nothing passes through anything, every end sits on a mount, and every overlap is drawn in depth order — for the Raptor, at rest, apart, and in every frame between. A line-end check fails any line that terminates in mid-air. Headless Chrome scripts take screenshots, close-ups, and slowed-down contact sheets, and — this is the detail worth pausing on — the skill instructs Claude to read every PNG it makes. The agent renders its figure, looks at the render, and fixes what it sees. That closes the loop that makes generated visual work unreliable: the model’s mental image and the actual pixels.

This is the pattern spreading across serious agent tooling right now. Skills that generate artifacts without a verifier produce plausible-looking output with structural defects; skills that generate and check produce output that has to survive contact with reality. Anatomy’s audit is narrow — it proves geometry, not correctness of the underlying concept — but it’s a real proof, run in CI, and the repo’s contribution rules require that kit changes leave every existing example byte-identical, which is a discipline most human-maintained drawing libraries don’t manage.

What it won’t do

The README’s limits section is unusually honest, and worth taking seriously. It is not a chart library: no axes, no series, no data plots. Numbers appear as a live readout driven by a small model, and as the true sizes and counts of the parts — which is elegant for mechanisms and useless for quarterly revenue. It draws machines, instruments, tools, and furniture; not people, not exact maps. An idea with no mechanism to build “will come out weaker,” which is a polite way of saying the metaphor engine has a domain.

It is also slow on purpose. A figure takes a long session — parts list, geometry, audit, close-ups of every joint in both themes. A full 3D orbit audit runs 15 to 20 minutes for 30 parts. The 3D mode itself is beta, proved on one example and one test figure, with a 380-part stress hand measuring about 20 fps at 1440 pixels and 13 to 15 fps on a throttled phone profile. The performance numbers are disclosed rather than hidden, which tells you the author knows exactly where the ceiling is.

And a caveat the sources force: there’s no external adoption evidence here. No star counts, no company endorsements, no third-party coverage in what I was given — just the repo’s own claims and its committed example pages. Whether the skill generalizes beyond its eight examples, or whether the figures it produces for your docs are as good as the ones in the gallery, is exactly the kind of thing the evals file gestures at but can’t prove. The production figures from a real site are two data points, not a movement.

A name that guarantees you’ll never find it

One practical note, delivered with affection: the project is named Anatomy, and searching for it will get you Vesalius and the NIH’s anatomy portal long before it gets you a Claude skill. The name is apt — the skill does dissect ideas into parts — but it’s a discoverability disaster in a search landscape dominated by medical anatomy resources. The website and the skills-CLI install path are the reliable routes.

Where this sits

Zoom out and Anatomy lands at the intersection of three currents. First, agent skills as a format: it follows the open Agent Skills specification, so the same folder loads in Claude Code, OpenCode, and Codex — a small but meaningful sign that skills are becoming portable rather than vendor-locked. Second, the shift from generated text to generated artifacts with verification, where the value is in the audit as much as the output. Third, the slow collapse of the assumption that explanatory graphics require a human with Illustrator.

The Icograms Designer of the world — 5,653 icons, 1,229 templates, drag-and-drop onto a 2:1 isometric grid — represent the human-in-the-loop version of this craft. Flourish represents the annotate-what-exists version. Anatomy represents the fully generated version, with the caveat that “fully generated” here means “generated by an agent following a very opinionated 300-line-plus rulebook, using a purpose-built zero-dependency kit, under mechanical verification.” That’s not a model spontaneously drawing well. That’s engineering the conditions under which a model draws well — which is, historically, how you get reliable output out of unreliable components.

The open question is whether the discipline transfers. The kit, the craft rules, and the audit are all specific to isometric machine illustration. But the pattern — invent the object, build it from real parts, prove the geometry, look at the render, fix what you see — is a template for any agent skill that produces visual work. The Raptor engine firing in its test stand is a nice demo. The loop that made sure no pipe passes through anything is the actual product.