algorithmic-art (Anthropic)

Review

Codex CLI 0.166 (gpt-6-astra, low reasoning) on a dedicated Windows test PC, a fresh temporary project and temporary HOME/TMPDIR/caches per run, skill installed (treatment) or absent (control) or absent with the skill's core requirement squeezed into one sentence appended to the prompt (one-liner group), 2 runs per group per task, network off, /tmp writes blocked. The prompts never mention the skill (except the wording noted below). Three tasks: a flow field of thousands of particles, an orbit/harmonic piece, and an open 'tide pools' brief, all asking for p5.js, seeded and adjustable output as files. The skill group uses the same prompt as control (skill is picked up by description match). The one-liner group adds one sentence: write a short algorithmic philosophy first, then code that is mostly generative, seeded, with parameter controls in an HTML viewer.

Three-arm comparison

Measured with Codex CLI over 18 runs, scored by rule-based checks with no LLM judge. Total 22.5 / 30, verdict Situational.

Verdict: Situational (22.5 / 30). Source: anthropics/skills, skills/algorithmic-art, pinned at commit ca45fc4. Install: npx skills@latest add anthropics/skills --skill algorithmic-art. Licence: Apache-2.0 / Anthropic terms (see LICENSE.txt in skill).

What it is

The algorithmic-art skill from anthropics/skills: a two-step procedure for generative art with p5.js: first write an 'algorithmic philosophy' (a named aesthetic movement, 4-6 paragraphs), then express it as seeded p5.js code in an interactive HTML viewer built from the skill's viewer.html and generator_template.js. Licence in LICENSE.txt (Apache-style for this skill).

How we tested

Codex CLI 0.166 (gpt-6-astra, low reasoning) on a dedicated Windows test PC, a fresh temporary project and temporary HOME/TMPDIR/caches per run, skill installed (treatment) or absent (control) or absent with the skill's core requirement squeezed into one sentence appended to the prompt (one-liner group), 2 runs per group per task, network off, /tmp writes blocked. The prompts never mention the skill (except the wording noted below).

Three tasks: a flow field of thousands of particles, an orbit/harmonic piece, and an open 'tide pools' brief, all asking for p5.js, seeded and adjustable output as files. The skill group uses the same prompt as control (skill is picked up by description match). The one-liner group adds one sentence: write a short algorithmic philosophy first, then code that is mostly generative, seeded, with parameter controls in an HTML viewer.

1. Flow-field art — Create generative art with p5.js: a flow field of thousands of particles. Make it explorable (seeded, adjustable). Deliver it as files in the current folder.
2. Particle system art — Make an algorithmic art piece with p5.js: particles orbiting several attractors, leaving trails. Seeded and interactive. Files in the current folder.
3. Open brief — Create an original piece of algorithmic art inspired by tide pools, using p5.js, with seeded randomness and parameter controls. Files in the current folder.

Scoring is programmatic (hidden tests / planted-issue recall / constraint checks / render+OCR where relevant), 0–5 per run. No LLM judge decided any score.

Results

The one-liner given to the third group: "First write a short algorithmic philosophy (a named aesthetic movement), then express it as p5.js code that is mostly generative algorithm, uses a seeded random generator so the same seed reproduces the piece, and exposes parameter controls in an interactive HTML viewer."

Mean score: 4.52 without vs 5.0 with the skill (delta +0.48). Tokens per run: 115k vs 229k (1.99x); time 181s vs 165s. One-liner group: 4.76 (the skill's gain over the one-liner: +0.24; one-liner's own gain over no skill: +0.24); one-liner tokens 145k per run, so the skill costs 1.58x the one-liner.

What happened

• Control already builds the basics: a viewer HTML, a seeded sketch and sliders in 6/6 runs. The score gap is almost all the philosophy check: control wrote only a README (126-226 words) and missed the 150-word threshold in 2 runs, and none of the 6 control runs produced a separate philosophy file. Mean 4.52 control, 4.76 one-liner, 5.00 skill.
• The skill makes the philosophy step reliable: 6/6 treatment runs wrote a philosophy.md (410-520 words), and the one-liner arm wrote one in 6/6 too (290-460 words). The only seeding failure in 18 runs was a one-liner run (t2-orbits) that used no randomSeed/noiseSeed at all.
• The skill adds output that was not asked for: export/save code (5, 8 and 3 download/saveCanvas references in the treatment viewers vs 1 in control), extra files (8.3 files per run vs 4 for control) and in 2 runs helper scripts (build_art.py, verify.cjs) that stitch the template together.
• Cost: 229k tokens per run for the skill vs 115k control and 145k one-liner, about 2.0x and 1.6x. Treatment read the skill in 6/6 runs without being told to.
• All arms except one one-liner run load p5.js from a CDN, so in the offline sandbox no piece could be rendered; the quality of the pictures is not compared.

Dimension scores

Limits of this test

• Rule-based checks only (file exists, seed functions, slider markup, word counts); 14 of 15 weighted checks pass for nearly every run, so the check set has a ceiling effect and cannot rank the art itself.
• No rendering: p5.js comes from a CDN, which the offline sandbox blocks, so none of the sketches was run in a browser.
• The 'philosophy' check accepts any .md with 150+ words, so a long README can pass; treated here by also counting separate philosophy files (see findings).
• n = 2 per group per task: differences under about 1 point are noise.
• Rule-based scoring measures what the checks can see; it cannot judge taste or whether a result is the best possible.

Security

See security.md. Scan: 0 CRITICAL / 0 HIGH / 0 MEDIUM. Verdict: safe to run (no-network sandbox). A clean scan does not prove a skill safe.

Bottom line

The skill reliably produces the two-part deliverable (named philosophy plus seeded, adjustable viewer) and the extra export features, but a one-sentence instruction gets almost the same checks for 60% of the tokens. Worth installing when you want that exact workflow and style; it is not a quality jump the checks can show.