Claude Opus 5.5 Rendered AI's History in Pure Code: What That Actually Demonstrates

A post on X says someone asked Claude Opus 5.5 to make a three-minute film about the history of AI — from "Attention Is All You Need" to AGI — with no stock footage and no image or video generators, every frame rendered from code. That is a demo claim from a single account, not a vendor announcement, and a film is the easiest artifact in this field to repost and the hardest to check. What is checkable is the class it belongs to. In the two days after the vendor shipped Claude Opus 5.5 on September 22, 2026, several people published code-rendered films and animations built with it, and a few of them published their source. That is enough to answer the question the post actually raises: what does "made 100% in code" mean, and what does a history of AI demand that a music video does not?

Short version, and it is the part reposts leave out. The model does not generate pixels. It writes a program that paints pixels, then runs it. The output of the interesting step is a renderer, not a film.

What "rendered from code" rules out — and what it leaves

The constraint in the prompt is doing real work, so it is worth stating precisely. No image model, no video model, no stock library, no licensed footage, no generated voice. Everything on screen has to be produced by arithmetic that someone wrote down.

What that leaves is a pipeline, and the shape of it is consistent across every one of these projects:

• Painting — a page using p5.js, Canvas 2D or WebGL, or a Python and NumPy loop writing pixel arrays directly. Colour, geometry, type and motion are all code.

• Rendering — something has to visit every frame in order. In the browser-based projects that is a Node script driving a headless Chrome instance and screenshotting the canvas; in the Python projects it is a loop writing image files.

• Encoding — ffmpeg joins the frames and lays the audio track on top.

At 24 frames per second, three minutes is roughly 4,320 frames. Nothing about Claude Opus 5.5 changes what frame 2,000 costs, because frame 2,000 is a screenshot of a canvas, not a model call. The model's job ends before the expensive part begins — and the expensive part is on your hardware, not on the API.

Why a history of AI is a harder brief than a music video

In a music video, the content is the song. The animation is decoration, and decoration can be abstract. A film about the history of AI has the opposite structure: the timeline is the content. If the film puts RLHF before the transformer, or skips the two years between GPT-3 and ChatGPT, it is wrong in a way that no amount of rendering quality repairs. Nobody watching a watercolour lyric video can tell whether the model understood the song. Anyone watching a three-minute history can tell whether the model knows the history.

That stacks three separate loads on one run. The model has to sequence facts correctly over a span long enough that it cannot hold the whole thing in one pass. It has to build and debug a multi-file renderer. And it has to make directorial choices — what to show, what to leave out, when to cut — because a history has to be edited or it is a list. Failure in any one of the three is invisible in a screenshot. A film with a beautiful renderer and a scrambled timeline looks fine until you read it.

The artifacts that hold up to inspection are the ones that published their source, and there are now several. A music video for a song called "I'm Upping My P(doom)" went up on GitHub on September 22 — the same day Claude Opus 5.5 launched — with a README stating it took two generations, the first credited to the model at medium effort and the second at default, that "everything in this repository was generated by the model," and that no scene ideas were specified beyond a character design and a general instruction to give each lyric interesting visuals. A three-game demo repo followed on September 23: three playable browser games, one single-sentence prompt each, no external assets, models and textures and audio all procedural. One of the three required the model to look up an existing game map's official layout and rebuild its geometry from that research before writing anything — the model deciding its first answer would have been wrong. And a reported four-minute code-only film, credited to four agents over about ninety minutes with no voice API, circulated the same week.

The specific history-of-AI film is not among the artifacts I could verify, and its runtime, prompt and timeline are the author's account rather than something an outside party has audited. Treat it the way you would treat any demo: the technique it demonstrates is real and reproducible; the particular film is a claim.

What three minutes of generated code actually costs

There is one independent measurement that describes this workload better than the demos do, and it comes from Artificial Analysis. On its Intelligence Index — version v4.3.2, ten evaluations — Claude Opus 5.5 scores 58 at maximum effort, which that page ranks first of 212 models. The same page puts the model at 260 million output tokens consumed across the Index suite, with a verbosity rank of 95th of 212, and a weighted average cost of $5.98 per Index task. Anthropic's list price is $4 per million input tokens and $20 per million output, with cache reads at $0.20 per million.

Read those two things together and the token profile is the story. A model that spends a lot of output tokens and lands mid-pack on verbosity is a model that is thinking on the page rather than compressing. Long-horizon generation is what that looks like from the outside: the budget goes into holding a large, multi-file, multi-hour build together, and the visible artifact is the residue.

The arithmetic, which is arithmetic and not a bill, since nobody has published the token cost of any of these films: at $20 per million output tokens, a run that emits 500,000 output tokens costs $10 in output. Input re-reads are where a long build gets expensive — a renderer that repeatedly re-reads its own growing source pays $4 per million on the way in, or $0.20 per million once the prefix is cached, which is a twentyfold difference and the single largest lever on the cost of a long agent run.

One caveat that applies to every number above and to Anthropic's own launch table. Most of the vendor's published benchmark rows are at maximum effort, while the default effort on the API is medium. Terminal-Bench 4.0 at 66.4%, CursorBench 4.0 at 52.5% at default medium, GDPval-AA v2.1 at 1,846 Elo — these are vendor-reported, unreproduced, and effort-dependent. Treat effort as the budget dial it is, not as a footnote.

Where the artifacts stop being usable

The failure modes in this class of work are consistent across every repo that published enough to check, and they are all structural rather than model-specific.

• The output is a program, not a file. If you need an MP4 to hand to someone, you still need Node, a browser and ffmpeg. The model produced the renderer, not the render. That is a build dependency you own forever, and it will break the first time the browser changes.

• It scales with frames, not with prompts. 4,320 frames is 4,320 screenshots. Nothing in the prompt shortens that, and nothing in the model's capability makes the last thousand frames cheaper than the first thousand.

• Determinism is a requirement, not a nicety. Frames render in parallel and out of order, so every frame must be a pure function of its timestamp — no carried state, no unseeded randomness, no dependence on when the frame happened to be computed. A model that has not internalised that produces a film that flickers, and the flicker is not visible in any single frame you inspect.

• One-shot does not mean unaudited. The clearest evidence is the map research: the model checked a published layout rather than trusting its own reconstruction. That is the behaviour you want and nothing in the prompt forces it.

• The facts are the part nobody checked. Every published artifact in this class reports its rendering pipeline. None of them reports a fact-check pass. For a history film that is the whole risk surface, and it is the one thing a screenshot cannot show you.

• Nobody has priced the failure. None of these repos reports how many attempts it took, how many tokens it burned, or how much of the second generation was repairing the first. That is the number a team needs before committing, and it is the number the demos are quietest about.

Running a three-minute render without betting a production path on it

If what you want is a film, Claude Opus 5.5 is not a video model and no amount of demo footage makes it one. Anthropic's launch material contains no video-generation capability; the published evaluations are agentic coding, computer use and knowledge work. What the demos show is long-horizon code generation pointed at something you can watch.

If that is the faculty you want, the practical question stops being which model and becomes how to run a multi-hour generation job without committing a production path to it. A render like this fails silently and late — you get a plausible program that paints for four minutes and then breaks at frame 3,000 — which makes it a bad candidate for a bespoke integration and a good candidate for an endpoint you already have. Claude Opus 5.5 is on OrcaRouter at Anthropic's list price with 0% markup — $4 per million input tokens, $20 per million output, cache reads at $0.200 — reachable through both the Anthropic Messages API and the OpenAI-compatible chat completions endpoint, so an existing SDK works by pointing its base URL at us. Put the overnight run on the same key as everything else, behind one API for 200+ models with automatic failover, and a run that dies at frame 3,000 is a routing problem rather than a re-architecture.

The cost lever is the cache, and it is worth configuring before the first render rather than after: at $0.20 per million cache-read tokens against $4 per million fresh input, keeping the growing source in the cached prefix is the difference between a cheap overnight job and an expensive one. That is true regardless of who serves the model.

What would settle the question

Three things would move this from a demo class to something you can plan around, and none of them requires a new model.

The first is published source for the history film specifically. The music video, the games and the pixel-engine films are checkable because their authors put the code up. The films that circulate as video only — including this one — cannot be distinguished from a carefully edited screen recording, and the difference matters most for exactly the artifact whose content is factual claims.

The second is an audit of the timeline. A three-minute history of AI is a test with a right answer, and the fact that the film is three minutes long is what makes the test hard: the model has to compress 2017 through today without dropping the load-bearing entries or inventing an order that never happened. Anyone can watch the film and check. Almost nobody has.

The third is cheaper capacity for the same job. Anthropic has said Sonnet 5.5 and Haiku 5.5 follow in the coming weeks. A cheaper model that can hold a multi-file build together turns an overnight render from a notable experiment into a routine one, and it would change the arithmetic on the failure budget — the number of retries you can afford — far more than it changes the quality of any single frame.

For now the honest read of the post is narrower than it sounds and more interesting than it looks. A model wrote a renderer, a plan and a timeline, and then a build process turned them into three minutes of video. The claim worth testing is not that the film looks good. It is that the timeline survived.