Build and Verify Deterministic Generative Art with Claude Code

What is genart?

genart is a Claude Code plugin that gives Claude specialized working knowledge for long-form generative art. It helps artists create deterministic, hash-seeded sketches suitable for platforms such as Art Blocks, 256ART, Verse, Highlight, Plottables, bootloader.art, and self-hosted releases.

The plugin supports creative-coding workflows built with Canvas 2D, p5.js, three.js/WebGL, and SVG. Its guidance covers pseudorandom number generation, token-hash seeding, resolution-independent rendering, traits, rarity, debugging, exports, platform integration, verification, and ethical practice.

The intended role of AI is a studio assistant rather than the artist. Originality, attribution, licensing, and AI disclosure remain part of the artist’s responsibility.

Key features

• Deterministic generation: Learn how to choose a PRNG, seed it from a token hash, organize named random sub-streams, and avoid common sources of non-reproducibility.
• Resolution independence: Design one composition so it can render consistently at both preview and high-resolution output sizes.
• Edition design: Develop features, traits, and rarity tables, then examine how they behave across many generated outputs.
• Multiple rendering technologies: Apply the guidance to Canvas 2D, p5.js, three.js/WebGL, or SVG projects.
• Production tooling: Add a debug interface, keyboard shortcuts, PNG export, and video export with Claude’s assistance.
• Verification: Run checks against a sketch before minting and understand what automated tests cannot establish.
• Platform guidance: Work from stable platform mental models and canonical documentation rather than copied details that may become outdated.
• Ethical guidance: Consider originality, attribution, licenses, and disclosure when incorporating AI into an artistic workflow.

Prerequisites

You need Claude Code and an existing or new generative-art project. Node.js is required to execute the plugin’s verification and rendering scripts.

The runnable scripts also require Playwright and Chromium inside your art project. The plugin itself is dependency-free and does not include a package.json or bundle Playwright.

Install the Claude Code plugin

In Claude Code, add the plugin marketplace and install genart:

/plugin marketplace add camilleroux/genart-skill
/plugin install genart@camilleroux-genart

After installation, describe your sketch and the skill should load automatically. You can also invoke it explicitly:

/genart

A useful first request is to explain the project’s current structure and propose a deterministic architecture before changing code. For example:

/genart
Review this Canvas 2D generative-art sketch. Help me seed all randomness from a token hash, keep traits stable, and render the same composition at different resolutions.

Install the rendering dependency

From the root of your generative-art project, install Playwright as a development dependency and download Chromium:

npm i -D playwright
npx playwright install chromium

If Playwright is missing, the supplied scripts report the installation command. Keeping this dependency in the project allows the plugin to remain dependency-free while its scripts run against your local sketch.

Build a deterministic sketch

Start from a token hash

Ask Claude to identify every source of randomness and route it through a seeded PRNG. The same token hash should initialize the same random sequence rather than relying on unseeded calls such as Math.random().

The plugin’s determinism reference also covers named sub-streams. These can help isolate different decisions, such as palette selection, layout, and texture, so that changing one part of a sketch does not unnecessarily disturb every later random choice.

Separate composition from output resolution

A deterministic result is not enough if the composition changes when the canvas size changes. Ask Claude to express positions, lengths, and other visual decisions in a logical coordinate system or as proportions, then scale the final rendering to the requested dimensions.

This makes it possible to render a lightweight preview at approximately 400 pixels and a production output at approximately 4000 pixels while preserving the same composition. The plugin describes this goal as perceptual stability across sizes, not necessarily pixel-for-pixel equality.

Define features and rarity intentionally

Traits should be stable for a given hash and meaningful across the complete edition. Ask Claude to help define possible values and rarity rules before relying on a small number of attractive samples.

A practical request could be:

Design stable traits for palette, density, and structure. Keep the trait calculation deterministic, document the intended rarity of each value, and help me test the resulting distribution across 5,000 seeds.

Run the determinism checks

The plugin ships a check.mjs script that runs in place. You do not copy it into the project, so plugin updates apply wherever the installed script is used.

node "$CLAUDE_PLUGIN_ROOT/scripts/check.mjs" myproject

Replace myproject with the relevant project path. The exact sketch contract and the small platform shim it requires are documented in references/verification.md.

Use this check before minting, but interpret the result carefully. It can help evaluate same-machine reproducibility, feature stability, and perceptual stability across sizes. It cannot prove that every machine, browser engine, or GPU will produce identical pixels.

Render and inspect one seed

Use render.mjs with --hash to render one deterministic output as a PNG:

node "$CLAUDE_PLUGIN_ROOT/scripts/render.mjs" myproject --hash 0x…

Replace 0x… with the token hash you want to inspect. This command supports a tight visual iteration loop:

1. Ask Claude to edit the sketch.
2. Render a fixed hash.
3. Inspect the generated PNG.
4. Describe what should change.
5. Render the same hash again and compare the result.

Keeping the hash fixed helps separate intentional code changes from variation caused by testing different seeds.

Evaluate the whole edition

Create a contact sheet

A single seed cannot show whether the project has enough variety or whether undesirable structures recur. Render a grid of 50 outputs:

node "$CLAUDE_PLUGIN_ROOT/scripts/render.mjs" myproject --grid 50

Use the contact sheet to inspect visual range, repetition, composition balance, rare outliers, and whether the collection still feels coherent.

Measure trait rarity

Run a census to see what the implemented rarity rules actually produce across a larger sample:

node "$CLAUDE_PLUGIN_ROOT/scripts/render.mjs" myproject --census 5000

This tests 5,000 outputs and provides an edition-level view of trait distribution. Compare the measured results with the intended rarity table. If they differ, investigate the code rather than assuming the design percentages are being followed.

Export individual PNG files

To render multiple outputs as separate files, use batch mode:

node "$CLAUDE_PLUGIN_ROOT/scripts/render.mjs" myproject --batch 50

This example produces a batch of 50 individual PNG renders for closer review or downstream use.

Use the platform reference sheets safely

The plugin includes guidance for Art Blocks, 256ART, Verse, Highlight, Plottables, bootloader.art, and self-hosted distribution. These sheets deliberately avoid volatile version numbers, field names, and copied figures.

Instead, they provide a stable mental model, canonical documentation links, and questions Claude should ask of the current documentation. When adapting a sketch for a platform, instruct Claude to fetch the official documentation before writing integration code.

Use the genart platform guidance for my target platform. Fetch its current canonical documentation before proposing integration code, and identify any assumptions that require confirmation.

This approach reduces the risk of implementing an outdated API or relying on configuration details that have changed since the plugin was published.

Advanced workflow tips

Use named random sub-streams

Separate randomness for major systems such as composition, palette, features, and texture. This can make the code easier to reason about and reduce accidental changes to unrelated visual decisions during iteration.

Test fixed seeds after every structural change

Maintain a small set of representative hashes, including common and unusual trait combinations. Render those hashes after changing PRNG usage, feature logic, dimensions, or rendering technology. Then supplement those checks with a grid and a larger census.

Do not confuse reproducibility with cross-machine proof

WebGL shader compilers, floating-point precision, rasterizers, and multisample anti-aliasing can differ between GPUs. JavaScript transcendental functions can also vary between engines. Therefore, the plugin does not claim that its tools prove cross-machine determinism.

Be precise when describing verification results. A successful test demonstrates only what was tested, such as repeatability in the current environment or stable traits over the sampled hashes.

Design export requirements early

If the final work needs high-resolution print, video, SVG, or pen-plotter output, discuss that requirement before the sketch architecture is fixed. The plugin includes guidance for PNG and video exports, resolution-independent rendering, SVG workflows, and pen plotters.

Keep the artist responsible for authorship

Use Claude to explain techniques, review code, run tools, and accelerate iteration. Keep creative direction, selection, originality checks, attribution, licensing decisions, and disclosure under the artist’s control.

Recommended end-to-end workflow

1. Install genart in Claude Code.
2. Open the generative-art project and explain its visual concept, rendering technology, and target output.
3. Ask Claude to design hash-seeded randomness and stable traits.
4. Make the composition independent of output resolution.
5. Install Playwright and Chromium in the project.
6. Follow the sketch contract described in references/verification.md.
7. Run check.mjs to identify detectable reproducibility problems.
8. Render fixed hashes and iterate on the images.
9. Generate a contact sheet to review visual variety.
10. Run a large census and compare measured rarity with the intended trait table.
11. Fetch current official platform documentation before implementing platform-specific code.
12. Prepare the required PNG, video, print, SVG, or plotter exports and document the limits of your determinism claims.

Conclusion

genart turns Claude Code into a focused assistant for deterministic generative-art development. Its references help structure the sketch, while its runnable tools support fixed-seed rendering, edition review, rarity measurement, and reproducibility checks. Used carefully, it can improve the technical reliability of a project without replacing artistic authorship or overstating what automated verification can prove.

The project is maintained by Camille Roux and released under the MIT license.