Anatomy: the open-source skill that teaches AI agents to draw machines

How do you explain caching to a client? Two thousand words with boxes and arrows will lose most readers. But show them a machine, say a pin-tumbler lock where every pin matches a bit field of the key, and when they all line up the plug turns and nothing gets recomputed, and the concept lands in seconds. That is the bet behind anatomy (github.com/wheresryan22/anatomy): the object is the explanation.

What anatomy is

It is an agent skill, a set of instructions plus a drawing library, for AI agents such as Claude Code, Codex, OpenCode, Antigravity and MiniMax Code. The repo has 12.4k stars, an MIT license, 152 commits and eight finished reference figures. The neural network never paints a picture; it writes code that assembles the figure deterministically: shading layers, painter’s order, springs, tick marks, screws.

The skill’s own table shows the mapping:

Concept	Object
One GPU context serving many canvases	A gantry plotter: one print head visiting 16 wells
A cache key that skips work	A pin-tumbler lock: pins match, the plug turns
Seven render targets, different bytes per texel	A chest of seven drawers, each as deep as its bytes
Separable blur, 49x49 taps vs 49+49	A bed-of-nails stamp beside two combs on rails

Three modes: pure SVG (isometric, four-tone shading), SVG plus WebGL (fire, exhaust, water, caustics) and a beta true-3D mode. Requirements are modest: Node.js 20.10+ and Chrome for the self-checks.

How it works inside

The repo ships its own drafting kit: a camera, turned bodies, pipes with flanges and clamps, a WebGL layer living in the same isometry as the linework. The interesting part is that the kit has self-checks, the way an engineering drawing does.

• Geometry audit: a script ray-casts every pipe against every solid, checks that tube ends sit on real mounts and that no bend pinches. Fail the audit and the build exits non-zero.
• Line-end check: every tick, seam and bevel must end on another stroke, a dot or an outline. In our figure, 674 line ends, zero floating.
• Screenshot runs in headless Chrome: both themes, a 390px phone profile, reduced motion and a no-WebGL fallback.

In other words, code review, but for a drawing.

Test case: a turbofan on a test stand

We stress-tested the skill on an awkward brief: a jet engine model with all its functions. The result lives right in this article:

Prefer it fullscreen? Open the example in a new tab{target=“_blank”} (there is also a dark version{target=“_blank”}).

What is inside:

• 191 parts: a 16-blade fan, a 3-stage low-pressure compressor, a 9-stage high-pressure compressor, a combustor with an annular liner and eight fuel nozzles, turbines, two coaxial shafts, a nozzle, an accessory gearbox with pumps, fuel and oil lines with flanges.
• Live physics: press Space and the starter spools the high-pressure rotor, ignition hits at about 24%, the engine settles at idle, the low-pressure rotor follows with realistic lag, and EGT and thrust respond.
• A throttle: drag the lever across the quadrant or use the arrow keys; the N1 and EGT gauges with redline sectors answer immediately.
• The exhaust is computed by a shader: a hot jet with Mach diamonds appears at high thrust, the combustor glows through the cutaway, the deck catches the light.
• Hover and the engine comes apart into ten assemblies along its axis, each labeling itself. Leave it alone and it runs a guided tour.

An honest number about effort: our first geometry audit failed with 129 thousand depth-order violations, because we had stacked parts the way real engines stack them, nested. The kit’s rule is different: rings with clearances, drums as stubs between them, shafts as through-rods. After the rebuild, violations dropped by an order of magnitude, and a full checked build takes about 23 minutes of pure computation. This is not a “make it pretty” button; it is an engineering pipeline, and that is exactly why the figure survives 4x zoom without a single drifting part.

Security check: what SkillSpector said

Before working with the repo we ran it through SkillSpector, as usual. The verdict looked scary: “100/100, CRITICAL, DO NOT INSTALL”, 632 findings. The breakdown showed false positives: 546 hits were “context stuffing” flags on the large documentation references (which are the point of the skill), 57 were tests the scanner could not finish within its runtime limits, and the rest landed on minified inline code inside shipped example pages. A manual review found no network calls beyond localhost for screenshots and no execution beyond headless Chrome. Clean. Same moral as in our SkillSpector review: a scanner verdict is a reason to investigate, not a verdict.

Who needs this in practice

Living drawings are content that holds attention and sticks in memory better than a stock GIF:

• Product blogs and media: explain architecture, comparisons, how things work.
• Documentation and helpdesks: instead of a thousand words, here is the assembly, here is what spins, here is what to adjust.
• Technical landing pages: interactivity a competitor cannot clone in two clicks.
• Education and onboarding: from how hardware works to the anatomy of your own pipelines.

At Automata we build figures like this to order: from the concept metaphor to an interactive diagram embedded in your page, with audits, both themes and a mobile profile. If you want your product explained in the language of machines, tell us what needs explaining.

📞 +7 (906) 311-77-69 · ✉ hello@automata.sale · 💬 Telegram: @automatasale · 🌐 automata.sale