by intincrab
A Claude Code skill that draws animated explainers like patent sheets
# Add to your Claude Code skills
git clone https://github.com/intincrab/blueprintGuides for using ai agents skills like blueprint.
See how blueprint compares with popular alternatives.
blueprint is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by intincrab. A Claude Code skill that draws animated explainers like patent sheets. It has 61 GitHub stars.
blueprint's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/intincrab/blueprint" and add it to your Claude Code skills directory (see the Installation section above). blueprint ships a SKILL.md manifest, so compatible agents can discover and load it automatically.
blueprint is primarily written in JavaScript. It is open-source under intincrab on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh blueprint against similar tools.
No comments yet. Be the first to share your thoughts!
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM lists this project for discovery and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
<blueprint-scene> element (or a standalone HTML page) with play, step and replay controls. Use when the user asks for a blueprint or patent-drawing explainer, an animated diagram of how a system, algorithm or process works, a "how X works" scene for docs, a README, a blog post or a talk, an explainer of an incident or postmortem, an explainer as a GIF, video, image or slides, or types /blueprint [topic].One scene explains one mechanism. The sheet starts empty. Each step draws in the parts it needs, moves something along a line, or changes a part's state, and shows one caption. Parts are numbered like a patent drawing, and the captions refer to them by number. The finished sheet must explain the idea on its own as a still image.
The drawing is done by runtime/blueprint.js. You never draw SVG: you write a scene, a plain object of parts, lines and steps, and the runtime draws it, animates it and adds the controls.
runtime/blueprint.js: the whole runtime. Defines <blueprint-scene>, BLUEPRINT.scene(id, spec) and BLUEPRINT.mount(el, spec, opts). Copy it unchanged.references/craft.md: the scene format, every part kind with its sizes and states, line kinds, step actions, the metaphor catalogue and the mistakes already made once. Read it before writing a scene.templates/scene.js: the starting point.templates/incident.js: the starting point for an incident or postmortem sheet (see Incident sheets).scripts/check.mjs: lints a scene without a browser (unknown ids, empty scenes, parts no step draws, overlaps, lines through parts or text, labels off the sheet, long captions).scripts/frames.mjs: renders the scene frozen at chosen moments into one contact-sheet PNG and reports runtime errors.scripts/build.mjs: turns scene files into a standalone HTML page with the runtime inlined.scripts/export.mjs: renders a scene to GIF, MP4 or PNG for places that cannot run JavaScript.examples/small/ (10 scenes, 3–6 steps) and examples/complex/ (11 scenes, 7–10 steps, camera moves). examples/small/cache.js is the cleanest small one, examples/complex/url.js the cleanest complex one.Find the mechanism. In one line: what goes in, what comes out, and what the reader should understand at the end. Then write the "but… so…" chain: the simplest version first, the problem it has, the part that fixes it, the next problem, and so on. Each link becomes a step. If you cannot write the chain, the topic is too broad: pick one mechanism inside it.
Pick the parts from the kit, using the metaphor catalogue in craft.md (a cache is a drawer, a queue is a rack of slots, auth is a lock and key, a rate limit is a tank). Pitch two or three framings in one line each and let the user choose, unless they said to just go.
Lay out the sheet on paper first. Flow runs left to right, layers top to bottom. Fix every part's centre (at) on a 20 px grid with at least 40 px between parts, then the lines, then the steps. Start from templates/scene.js.
Lint it until it prints clean (it also flags a line running through a label, numeral or note, and parts or lines that no step draws):
node <skill-dir>/scripts/check.mjs path/to/scene.js
<skill-dir> is the folder this SKILL.md is in. Fix every warning unless the overlap is deliberate.
Look at it. Render a contact sheet and Read the PNG:
# once, in <skill-dir>: npm i && npx playwright install chromium
# (or in a scratch dir: npm i playwright@1.56.1 && npx playwright install chromium, and prefix NODE_PATH=<scratch>/node_modules)
node <skill-dir>/scripts/frames.mjs path/to/scene.js --out /tmp/scene.png
It exits 1 if the scene has errors or the page throws. The default sheet shows the middle and the end of every step. Pick other moments with --frames "s2:0.4,s3:end,end". Check that nothing is cropped, no text sits on a line or a part, every token is visible where it should be, the camera frames what the caption talks about, and the last frame explains the whole idea on its own. Two or three rounds is normal.
Ship it. Either embed it:
<blueprint-scene scene="cache" play="view" key></blueprint-scene>
<script src="/blueprint/blueprint.js" defer></script>
<script src="/blueprint/cache.js" defer></script>
(blueprint.js must come first in document order), or export one page: node <skill-dir>/scripts/build.mjs scene.js --out scene.html.
When the user asks for a GIF, video, image or slides, or the sheet is going somewhere that cannot run JavaScript (a GitHub README, Slack, X, Notion, a deck), export it:
node <skill-dir>/scripts/export.mjs scene.js --format gif # README, Slack
node <skill-dir>/scripts/export.mjs scene.js --format mp4 # X, LinkedIn, talks
node <skill-dir>/scripts/export.mjs scene.js --format png # the finished sheet, 2x
node <skill-dir>/scripts/export.mjs scene.js --format png --steps # one PNG per step, for slides
--format all writes all three. Useful options: --out (a name ending in .png/.gif/.mp4 sets the file name and each format keeps its own extension; anything else is a folder), --scene <id> (for a file with several scenes), --width (default 1280), --speed (GIF 1.8×, MP4 1.25×; it speeds up the motion only, and rests keep their real seconds so captions stay readable), --fps, --paper, --audio track.mp3 (MP4 only; the video sets the length). Keep a GIF under about 5 MB: export.mjs warns past that, and a complex scene usually fits with --width 960. GIF and PNG need only Playwright. MP4 uses ffmpeg when it is on PATH; otherwise Chromium encodes it (WebCodecs), which covers macOS with nothing else installed; on Linux install ffmpeg, or set BLUEPRINT_CHROMIUM to a distro Chromium with H.264 (Fedora's has it). --encoder ffmpeg|browser forces one. Exports do not carry the scene's sources: give the user the links to post with it. Read one exported frame or the PNG back before handing it over.
scene: the id given to BLUEPRINT.scene('<id>', …).play: loop (default: plays, fades and starts over), view (plays once when it scrolls into view, then holds the finished sheet), click (waits for a click), still (shows the finished sheet).paper: blue (cyanotype, default) or linen (ink on cream, the patent-office look). A scene can set its own with paper: 'linen'.key: shows the parts list under the sheet ("1 Cache · a drawer by the door…") from each part's name and note.no-controls: hides the play, step and replay bar. Clicking the sheet still pauses and plays.no-font: does not load IBM Plex Mono from Google Fonts.speed: playback rate of the motion, e.g. speed="1.25". Rests play in real seconds, so captions keep their reading time.When the topic is an outage, a breach or a postmortem, start from templates/incident.js and keep its story shape: a normal day, the change or trigger, what broke (with a number), how it was noticed, what stopped the damage, recovery, the root cause in plain words, the fix that prevents it (the "So…" step), and a timeline in the last step's note.
sources ([['Postmortem', 'https://…'], …], http(s) only); the site and build.mjs pages list them under the sheet, but GIF, MP4 and PNG exports do not, so pass them on with the export. If a fact is missing, ask for it or leave it out; never invent one.These come from the reading behind the style (Byrne, Victor, Ciechanowski, Thing Explainer, patent drawing conventions). Keep them.
#42, the name example.com, three key presses. The general rule comes at the end, after the reader has watched one real case.name and note for the key.CACHE) and the key, once.hold and each step rests long enough to read its caption (about 17 characters a second); check.mjs warns when an explicit hold is too short for its caption.~120 MS, 4 KB, 3 TRIES. Use the dim line for a measured span.view) zooms to the part being discussed, then pulls back. End complex scenes on the full sheet.Blueprint is a skill for Claude Code. Give it a topic and it returns an animated explainer: parts drawn in with numbered leader lines, things moving along the lines, and one plain sentence per step. It ships as a single <blueprint-scene> element or a standalone HTML file, and the finished sheet still explains the idea as a picture.
npx skills add intincrab/blueprint
Or clone it into your skills folder:
git clone https://github.com/intincrab/blueprint.git ~/.claude/skills/blueprint
It needs Node 18 or later. Playwright is optional: it lets Claude render frames of a sheet to check its own work, and it is what the GIF, MP4 and PNG exports run on. To set it up, run this once in the skill folder:
cd ~/.claude/skills/blueprint # or wherever the skill was installed
npm i # installs playwright@1.56.1 from package.json
npx playwright install chromium # downloads the browser it drives
Linting (scripts/check.mjs) and building a page (scripts/build.mjs) need nothing but Node.
Offline, or on a distro that ships its own Chromium, skip the download and point the scripts at it: BLUEPRINT_CHROMIUM=/usr/bin/chromium-browser node scripts/export.mjs … (works for frames.mjs too).
/blueprint how a cache works
/blueprint our signup flow, for the docs page
/blueprint why the retry storm took the API down
/blueprint the event loop, as a complex scene
/blueprint how a cache works, as a gif
/blueprint last night's outage, from this postmortem
Claude finds the chain of reasons in the topic, picks parts from a kit of 28 (drawers, cabinets, gears, gates, locks, clocks, queues and more), lays out the sheet, lints it, looks at every step, and then embeds it in your page or exports a file.
Every part has to earn its place. A sheet starts with one real case and adds a part only when the last one falls short:
The app asks the database for item #42. Every request makes the long trip, and each lookup takes 120 ms. So a drawer by the door keeps recent answers. But the first time it is empty, so it fetches once and keeps a copy. The next request is answered in 2 ms.
That chain of "but… so…" is the explanation, and the animation above is that paragraph drawn.
Watch any of them at blueprint.intincrab.com, where you can step through each one and copy its source.
<blueprint-scene scene="cache" play="view" key></blueprint-scene>
<script src="/blueprint/blueprint.js" defer></script>
<script src="/blueprint/cache.js" defer></script>
| Attribute | What it does |
|---|---|
play |
loop (default), view (plays once when scrolled into view), click, or still (the finished sheet) |
paper |
blue (cyanotype, default) or linen (ink on cream) |
key |
Shows the numbered parts list under the sheet |
no-controls |
Hides the play, step and replay bar |
speed |
Playback rate of the motion, e.g. 1.25; rests stay in real time so captions keep their reading time |
no-font |
Uses the reader's own monospace font instead of fetching IBM Plex Mono from Google Fonts |
Load blueprint.js before the scene files; defer keeps that order. If a scene can't be found (a misspelled scene, or its file loaded before the runtime), the element says so in the sheet's place and in the console.
Every sheet has play and pause, previous and next step, and a step bar. With reduced motion turned on it shows the finished sheet. The runtime is one file with no dependencies. By default it loads IBM Plex Mono from Google Fonts; add no-font (or pass --no-font to build.mjs and export.mjs) and the page makes no outside requests.
GitHub READMEs, Slack, X, Notion and slide decks can't run the element, so export the sheet:
node scripts/export.mjs examples/small/cache.js --format gif # loops in a README or Slack
node scripts/export.mjs examples/small/cache.js --format mp4 # for X or a talk; add --audio track.mp3
node scripts/export.mjs examples/small/cache.js --format png # the finished sheet at 2x
node scripts/export.mjs examples/small/cache.js --format png --steps # one image per step, for slides
node scripts/export.mjs examples/small/cache.js --format all --out out/cache.png # out/cache.png, .gif, .mp4
Or just ask: /blueprint how a cache works, as a gif. Exporting needs Playwright (see Install). --out ending in .png, .gif or .mp4 names the files (each format keeps its own extension, and --steps adds -01, -02…); any other --out is a folder. A file with several scenes exports the first; pick another with --scene <id>.
MP4 needs an encoder. With ffmpeg on your PATH it uses that, with libx264, or libopenh264 where ffmpeg has no libx264 (Fedora's build). Without ffmpeg, Chromium encodes the video itself (WebCodecs) and the script writes the MP4, so on macOS nothing else is needed (Windows should work the same way, but is untested). That needs the full Chromium, which npx playwright install chromium downloads alongside the headless shell. On Linux, Playwright's Chromium has no H.264 encoder, so install ffmpeg (apt install ffmpeg, dnf install ffmpeg-free), or point BLUEPRINT_CHROMIUM at a distro Chromium that has one (Fedora's does). Such a Chromium may still lack AAC; then --audio needs ffmpeg, and the script says so before it renders anything. --encoder ffmpeg or --encoder browser picks one. With --audio, the video sets the length: a shorter track ends in silence, a longer one is cut.
A scene's sources (the links behind an incident sheet) are not drawn into GIFs, videos or images. Put them in the post, the slide notes or the README next to the export. scripts/build.mjs lists them under the sheet.
templates/incident.js gives an outage a ready-made story: a normal day, the change, what broke, how it was noticed, the fix that stopped it, the root cause, and the change that prevents it next time, ending on a timeline. Hand Claude your postmortem and it fills the template with your facts, links the sources, and keeps the wording blameless. The eMudhra key compromise shows the same shape for a public incident.
To send a sheet to someone as a single file:
node scripts/build.mjs examples/small/cache.js --out cache.html
node scripts/build.mjs a.js b.js --out explainers.html --title "How our API works" --play view --paper linen
The page inlines the runtime and every scene, and lists each scene's sources as links under it.
| Path | Purpose |
|---|---|
SKILL.md |
What Claude reads first: the workflow and the style rules |
references/craft.md |
The scene format, the part kit, line kinds, step actions, and which part suits which idea |
runtime/blueprint.js |
Layout, timeline, SVG re |