Anatomy Turns Claude Code Into an Illustrator That Checks Its Own Work

A trending Claude skill explains code concepts by drawing working machines. The part worth copying is how it makes the agent prove each drawing is right.

Ask a coding agent for a diagram and you usually get boxes and arrows. Some arrows point at nothing. A label floats next to the wrong box. It looks finished, and nobody checks, because checking a picture is tedious and the agent already said it was done.

Anatomy takes the opposite position on both counts. It is a skill for Claude Code that explains an idea by inventing a physical machine whose working parts are the concept: a Bloom filter becomes a fruit machine, a TCP handshake becomes a mail ropeway between two stations. Then it refuses to hand the figure over until a set of scripts says the drawing is clean.

The drawings are what put it on GitHub's trending boards. The checking is what makes it worth studying. It shows a pattern any skill author can borrow: give the agent its own inspectors, and make "done" mean a script printed zero.

What anatomy is

A skill, in Claude Code's sense, is a folder of instructions and helper files that the agent loads when a task matches. Anatomy is one of those folders. Its README describes it as "a Claude skill that explains an idea by building it as a real, working object," and it also runs in OpenCode and Codex.

The numbers, as of October 12, 2026: somewhere between 5.5k and 5.7k GitHub stars depending on which counter you read that afternoon, an MIT license, and version 1.1.0 released that day, two days after 1.0. It was #2 on Trendshift, a site that ranks GitHub repos by momentum, when I checked the live board at about 3:08 PM ET on October 12. Live boards move, so treat that as a snapshot.

Output is a standalone HTML page, a single SVG file, or React components. SVG is the vector image format browsers draw natively, so the figures stay sharp at any size and need no image files. The examples are interactive. You can wind a watch movement, spin up a jet engine, or turn a "temperature" knob on a roulette wheel whose pockets are sized by next-token probability, which is a better explanation of LLM sampling temperature than most paragraphs manage.

The project page lists 33 figures, from a post-office sorting desk for hash collisions to a bookcase for an LRU cache.

The trick: the object is the explanation

Most diagram tools start from the concept and draw symbols for it. Anatomy's SKILL.md, the instruction file the agent reads, starts somewhere else. Step three of its workflow is "Invent the object": pick a machine whose mechanism maps onto the idea. Its own phrase for the result is that the object is the explanation.

That forces the agent to understand the concept before drawing. A Bloom filter as a fruit machine only works if three reels stand in for three hash functions and the machine pays out only when all three flags are set. Get the mechanism wrong and the machine visibly does not work.

The workflow puts truth before looks. Step two collects "the real numbers and behaviour" first, so the readout, the motion and the caption are all true. The seasons figure computes daylight hours from solar formulas instead of approximating them.

The part worth copying: the agent inspects its own work

Here is where anatomy gets unusual. The skill does not ask the agent to make the drawing look good. It writes its craft rules as things a script can check, then makes the agent run the scripts.

A few of the rules, from SKILL.md:

"Lines resolve." Every line ends on a face, another line, or a dot. No floating labels.
"No pipe or cable passes through anything," at rest or mid-animation.
"Solids, not wireframes." No see-through edges.

And the checks that enforce them, from the verification guide:

A geometry audit. For figures with build scripts, and especially ones with pipes, cables or round parts, the build runs with --audit and must end with audit passed. Anything else lists the problems.
A line-end check. node scripts/lines.mjs page.html --out shots/lines.png must report zero loose line ends, in both light and dark themes.
Screenshots the agent has to read. A script drives headless Chrome (the browser running without a window) and captures the figure at desktop width, at a 390-pixel phone width, on hover, and zoomed to 4x on every joint. The agent is told to look at each image "the way a demanding reviewer would, before anyone else does."

Think of it like a building inspector who carries a checklist and a tape measure instead of an opinion. "Does this look right?" is a judgment the model will happily answer yes to. "Did the line checker print 0?" is a fact it cannot talk its way around.

This is the idea to take away even if you never draw a machine. Agents are bad at grading their own taste and good at running a command and reading the result. Anatomy turns taste into commands.

Put this into practice

Try anatomy in ten minutes

The skill itself needs Node.js 20.10 or newer and a Chrome or Chromium install for the checks. There is nothing to npm install; the kit uses Node's built-in modules only. One catch: the skills installer used below asks for Node 22.20 or later in its current version (1.7.1), so upgrade Node first or use the git clone route the README also documents. React output needs React 18 or newer.

Install it for Claude Code across all your projects:

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

Swap claude-code for opencode or codex to target those agents, or drop -g to install it for the current project only. The README notes the command copies about 10 MB. If Claude Code is already running, you may need /reload-skills before it shows up.

Then ask for a figure (in Codex the trigger is $anatomy instead of /anatomy):

/anatomy explain how a token bucket rate limiter works, interactive

What to expect: the skill first sizes the request as a Figure, a Hero or an Epic, gives you a time estimate, and will not start an Epic unless you choose it. A small figure takes a while. A large one takes much longer. The README is blunt about it: "It is slow on purpose." The SpaceX Raptor engine example takes a few minutes just to build, and a full 3D orbit audit runs 15 to 20 minutes for a 30-part figure.

If you use Codex, its sandbox (the walled-off space where Codex runs commands) can block the browser checks. The simplest fix is to approve the run when Codex asks. The README also has a short ~/.codex/config.toml block for a standing fix; copy it from there, since it notes "Newer Codex releases may name these settings differently." Skip --sandbox danger-full-access: it works, but it "lifts every limit for that session."

Steal the pattern for your own skills

You can apply anatomy's approach to any skill you write, whether it produces diagrams, migrations or docs. Three moves:

Rewrite each quality rule as a check. "Keep functions short" is taste. "No function over 60 lines, checked by scripts/fn_length.py" is a fact.
Make the check print one number that must be zero. Anatomy's scripts end in audit passed or a count of problems. That gives the agent an unambiguous finish line.
Make the agent read its own output. For anything visual, that means screenshots it must open. For text, it might mean rendering the Markdown or running the generated code once.

A rule in your own SKILL.md could be as plain as this example:

Before you say you are done, run `python scripts/check_links.py docs/`.
It must print "broken links: 0". If it prints anything else, fix the
links and run it again. Do not report success until it prints 0.

That one paragraph does more for quality than a page of adjectives.

Honest limitations

It is slow, by design. If you need a quick diagram for a pull request description, this is the wrong tool. It trades speed for correctness, and it says so.

3D is beta. The README says the 3D mode is "proved on its example and one test figure, not yet on a production figure." Its frame-rate figures, around 60 fps for a small figure and about 20 fps for a 380-part stress test, are the author's own measurements.

It draws machines, not data. "It is not a chart library," and it does not draw "people or exact maps." For a bar chart, use a chart library.

The checks cover geometry, not truth. A clean audit means no loose lines or parts passing through each other. It does not prove the machine you invented explains the concept correctly. You still have to read the figure and ask whether the metaphor holds.

Token cost is unknown. Long builds with many screenshots and audit passes will use a lot of context. The project does not publish typical token counts, so watch your usage on the first few runs.

One more note: version 1.1.0 added publishing to a community gallery. The agent sends a figure only when you ask, shows you what it will send, and opens a pull request after you confirm. Nothing goes out by default.

Where this leaves you

Anatomy is fun, and the figures are the best visual explanations of hash maps and mutexes most developers will see this year. The bigger lesson is in its verification guide. The skill does not trust the model's sense of done. It hands the model a checklist, a tape measure and a camera.

Pick one skill you already use and find the rule in it that the agent keeps breaking. Turn that rule into a script that prints zero. See how much less you have to review.

Sources: wheresryan22/anatomy README, SKILL.md and references/verify.md at the v1.1.0 tag (released October 12, 2026); anatomy releases; project page; Trendshift daily board, read about 15:08 ET on October 12, 2026.

Medium metadata

Title: Anatomy Turns Claude Code Into an Illustrator That Checks Its Own Work
Alternate titles: "Anatomy Turns AI Into a Self-Checking Technical Illustrator" / "You Don't Have to Trust Your Agent's Diagrams Anymore" / "This Claude Skill Won't Say It's Done Until a Script Says Zero"
Subtitle options: (1) A trending Claude skill explains code concepts by drawing working machines. The part worth copying is how it checks them. (picked) (2) Anatomy draws a Bloom filter as a fruit machine, then makes the agent prove the drawing is clean. (3) The best idea in this skill is its verification guide.
Description: Anatomy, a trending Claude Code skill, draws working machines to explain code ideas and makes the agent pass audits before it is done.
Tags: Claude Code (product search), AI Agents (core beat), Developer Tools (practical reader), Data Visualization (the output), Prompt Engineering (the copyable pattern)
Article type and plan: Type A (spike: a real repo with a release today and a clear payoff). Post at 7 to 8 AM ET, let Medium distribute for 2 to 6 hours, send to subscribers only if it is performing.