anidoodle: Hand-drawn art, written as code

TL;DR

anidoodle is an open-source (Apache-2.0) skill package by Alex Greenshpun that lets a coding agent (Claude Code, Codex, Grok Build, or any harness that reads the skills/anidoodle/SKILL.md folder) produce hand-drawn illustrations, drawing timelapses, interactive web art, launch films, and scored short films by writing deterministic rendering programs rather than sampling pixels. Thirty-two drawing styles — pencil-and-watercolour, risograph, woodcut/ukiyo-e, single-line engraving, pixel art, toy-brick, sumi-e, embroidery, etc. — are each implemented as a code recipe where every mark is a function of control points and seeded randomness; the same source renders bit-for-bit identical output on every machine. Twenty-one music vocabularies (code-composed, with an optional 373 MB sampled-instrument pack) and a launch.mjs kit for product-launch films round it out. It is a worked, shippable instance of the “code-native visual generation” thesis — not a research artifact, but a concrete reference implementation of what an agent-authored, deterministic, editable art pipeline looks like in 2026.

Key claims

Each of 32 drawing styles is a code recipe over control points, seeded randomness, and style-specific mark-making functions (nib taper, chalk scumble, risograph halftone, scratchboard white-on-black, single-line engraving width-as-tone, etc.), so a finished illustration is one pure function called once, a sticker is the same function on a loop, and a film is the function plus a story and a score [§“32 styles to choose from” / §“How each one is made”].
Determinism is a first-class guarantee: pure functions plus seeded random mean anyone with the source rebuilds the exact same piece byte-for-byte, every time, on every machine — a design discipline documented in references/determinism-and-contract.md and enforced by a gate.mjs tool that checks determinism, contract, and dead-air in one pass [§“Honest by design” / §“Get started”].
Every style ships both the finished picture and, from the same source, a timelapse film of it being drawn in the order an artist in that medium would work (watercolour: pencil, then washes light-to-dark; woodblock: keyblock then colour blocks; pixel art: flat blocks then shading) — the timelapse, the making-of, and the explainer diagram collapse into one artifact [§“Every style draws itself”].
Music is composed in code from 21 genre vocabularies (lo-fi, house, synthwave, orchestral, jazz, folk, solo piano, …); nothing in the repo is a recording unless an optional sampled-instrument pack (373 MB, 8 acoustic instruments across 3 recorded rooms) is installed; a music.mjs check tool verifies key/mode, loudness, masking, part balance, and novelty (fails scores that quote known ones) [§“Music, composed in code”].
Four render backends share one art core (playwright, html-player, remotion, hyperframes); every format ships from the same source — PNG, MP4 with score, GIF, WebM, animated PNG with transparency, and one self-contained ~100 KB HTML file that plays the piece offline on a double-click [§“Get started” / §“It draws, then it moves”].
A launch.mjs new <name> → launch.mjs ship <name> kit auto-cuts a product-launch film at 4 aspect ratios (16:9 / 1:1 / 4:5 / 9:16) with synchronized sound effects and a composed score, enforcing a set of launch-video craft rules (say what it is within 5 seconds, never put words over the art, cut on the downbeat, make the first frame the thumbnail) [§“Launch your product, drawn in code”].
Cost argument: a picture model spends tokens/compute on every frame of every render and draws something new each time; code spends them once — the demo 47-second film renders 1,410 frames and a full stereo score from one program, ~60 tokens of code per frame on first pass and zero on every pass after [§“Pay once, draw forever”].

Method

anidoodle ships as a standard skills folder (skills/anidoodle/SKILL.md) that any plugin-aware coding agent can install (/plugin install anidoodle@alexgreensh-anidoodle in Claude Code, equivalents in Codex and Grok Build). The agent reads the skill’s references/ library — six documents on storytelling, realism-and-craft, styles, music, determinism-and-contract, and working-method — and routes a plain-English request (“draw a pencil & watercolour pear for our recipes page”) to the right workflow and style recipe. Each style is a module under engine/src/canvas-core/ with its recipe written at the top of the file: control-point placement over real anatomy, mark-making functions parameterized by a seeded PRNG, and a cache key naming every input a pixel depends on. The CLI exposes atomic tools: still.mjs (print-size illustration), render.mjs (loop/film/alpha), emit.mjs (self-contained HTML), gate.mjs (determinism + contract + dead-air), verify-export.mjs (decoded-file checks on shipped MP4), music.mjs check (score validation), and launch.mjs new/ship (launch-video pipeline). The example film Mechanical Lepidoptera (1,410 frames, 47 s, clockwork butterfly drafts itself → comes alive in watercolour → leaves its blueprint in grass) is included as the end-to-end reference piece — control points placed by hand over real butterfly anatomy, cache keys that name every pixel’s dependencies, a score composed for it, and one unbroken move from built to alive.

Results

No benchmarks — this is a shipping tool, not a research artifact. The repo demonstrates: 32 fully-worked style recipes with timelapse variants; 21 music vocabularies plus 8 sampled instruments across 3 recorded rooms; 4 output aspect ratios for launch videos; one 47-second end-to-end example film (1,410 frames + stereo score) generated from a single program; and gate.mjs passing determinism, contract, and dead-air checks on the shipped artifacts. Requires Node ≥ 20 and ffmpeg for anything that moves.

Why it’s interesting

anidoodle is the clearest production-grade instantiation on the wiki of the thesis in The Next Frontier of Visual AI Is Code — that for visual tasks where users want to keep iterating, the right output of a generative system is the source program that produces the pixels, not the pixels themselves. Where OmniLottie: Generating Vector Animations via Parameterized Lottie Tokens makes Lottie model-native so an LLM can author editable vector animations, and VecGlypher: Unified Vector Glyph Generation with Language Models does the same for SVG glyph paths, anidoodle extends the move to expressive hand-drawn-looking art across 32 styles plus synchronized music — and ships it as a Claude Code / Codex skill that any coding agent can drive today. Two things stand out for the team: (1) the determinism contract (pure functions + seeded PRNG + cache-key-names-every-input) is the discipline that makes the Code → Render → Inspect → Revise test-time loop from the a16z essay actually converge rather than drift between retries — a lesson any code-native generation pipeline will have to pay; (2) the mark-making-as-code axis is a concrete answer to Vincent Sitzmann’s bitter-lesson counterpoint in The flavor of the bitter lesson for computer vision — anidoodle doesn’t try to learn a woodcut’s hand from data, it writes it as a program, and the artifact’s value (identical renders, editable at any level) is exactly the thing a pixel-native model cannot ship. The limitation is the same as the rest of the code-native cluster: style breadth is bounded by what someone sat down and wrote a recipe for; it’s additive, not generative-over-styles, and does not learn new hands from one example (the “match a style” feature in the readme is still inside the 32-style vocabulary).