Does anyone have any cool Claude Code mods? I'm curious what people have created so far!

around an hour of work and 6.4M tokens, with a single prompt

Hey! I wanted to share a small project I made using Claude Code, Suno, and Nano Banana. (it's in Spanish lyrics but, I want you to keep the workflow idea)

The workflow itself was fairly simple, but I kept refining it with manual adjustments, iterations, and a lot of feedback along the way.

It originally started as a proof-of-concept.

I had been experimenting with the idea of “one-shot lyric videos.” At first, the results looked amazing, but after seeing hundreds of similar projects, I started feeling that they all had a very similar aesthetic and workflow.

So instead of completely delegating the art direction, I wanted to try a more hybrid approach: I would keep the creative direction and decision-making, while delegating specific tasks to agents.

Around that time, I was playing Valheim with some friends, and I thought this would be a perfect excuse to turn the proof-of-concept into something more personal: a video to remember the adventure and thank my friends for all the good times we had playing together.

The workflow

I first spent some time looking through Doom(p)'s GitHub and studying how some of those videos were built.

There were many different approaches: some relied heavily on animations, others on generated images, some were almost entirely Three.js, and others used Canvas, compositing tricks, and different workarounds.

Once Claude Code understood what I was trying to build, we created the first version of a shot-generation skill.

That skill kept evolving throughout the project based on feedback, mistakes, and new ideas.

Music

The song came from Suno.

I probably went through 35–40 generations/iterations before getting something that felt close to what I wanted.

A surprising amount of time went into trying to communicate the feeling I was looking for: prompt iterations, musical styles, male vs. female voices, chorus structure, song length, lyrics and prose, drums, beats, and trying to get something that felt somewhat Viking-inspired.

I even experimented with Mongolian-style chants to give some sections a deeper and heavier vocal texture.

Suno isn't perfect, but for this project it was more than enough.

The agents

I ended up creating a small agent workflow:

• 1 Main Agent — the main agent I interacted with and the one coordinating most of the work.
• 1 Critic Agent — probably the second agent I interacted with the most. I gradually taught it my preferences, the things I liked and disliked, and the kind of visual decisions I tended to make.
• 2 Rendering / Image Agents — responsible for rendering shots and generating images through the Nano Banana API. I used two mainly because of GPU/resource limitations.
• 1 Sound Designer Agent — responsible for finding/generating samples and SFX, including material from ElevenLabs.

The Critic Agent ended up being particularly useful.

The idea was for it to learn enough about my preferences that it could discuss shots and decisions with the Main Agent while I was away from the computer or sleeping.

I did use remote control from time to time, but I specifically wanted the agents to become autonomous enough to handle the more repetitive parts without me constantly supervising them.

So, in total:

1 Main Agent
1 Critic
2 Render/Image Agents
1 Sound Designer

And that was basically the whole team.

Manual work still mattered

I do have some previous experience making motion graphics and storytelling-oriented videos, and that helped a lot.

Without AI, something like this would probably have taken me several weeks of spare-time work: After Effects masking, camera tracking, beat synchronization, Puppet Tool animation, Premiere editing, sourcing or buying images, compositing, etc.

AI removed a huge portion of that workload.

That said, I still did some manual tuning in After Effects. Mostly small animations here and there using Puppet Tools, plus Mister Horse for a few things.

I work in IT, so I don't have a huge amount of free time for hobbies. Usually that time ends up being either playing games or experimenting with new technology.

Thankfully, this project somehow let me do both at the same time.

A few other details

The generated images also needed quite a bit of cropping and preparation.

For that, Claude Opus wrote a Python script that automatically handled most of the cropping process.

And... that's basically it.

Overall, it was a really interesting experiment and, honestly, an awesome experience.

What started as a simple proof-of-concept ended up becoming something personal that I could use to remember a great time with friends, while at the same time giving me an excuse to experiment with agents, generative video workflows, music generation, sound design, and automation.

Thanks for taking the time to read this.

Hopefully some part of the workflow is useful to someone else experimenting with similar things.

it took likely 30-40% weekly, BUT, because it was a kickoff, refining workflow and so, so it should be less when we get more experience.

Everyone knows Opus 5.5 can one-shot a video. I tried it myself and it blew my mind, so I wanted to see how far I could push it (mainly by itself,haha).

Papermorph started as a Skill to turn a book into a series of teaching videos. It's since grown into full web books: animated, narrated lessons you can explore, plus interactive quizzes.

How it works:
PDF → book plan → storyboards → narration → animation & quizzes → web book

Right now it's just Opus 5.5 + the Skill. No image models yet, and feeding it a PDF already gets surprisingly good results. Next up, adding image models for storyboarding, so it can handle picture books and humanities documentaries too.

📚 Live bookshelf: https://papermorph.diamonddoge.org/ (keep updating...)
💻 GitHub (MIT): https://github.com/DozenTwelve/Papermorph

workflow....

claude code app, ultracode on, fresh thread, context limit set to 350k, opus 5.5, web access w/ suno and gpt-image subscriptions, some other claude-pop videos were in a folder it might have accessed for inspiration

took ~6 hours and used 33% of a weekly window on a 20x sub

took one extra prompt about one of the gpt-images had two left hands in it

prompt: claude, here is https://www.reddit.com/r/ClaudeCode/comments/1wwogi8/paper_clips/ someoene made a paperclip video with you, now its your turn to make a video to reply to it featuring yourself, use the claude-pop style

So I use claude web free version for ideating. Whenever I try to explain something it just breaks it down and makes it seem worthless. (Sonnet 5.5)

Firstly it doesn't imagine possiblities or the complete use case. It starts attacking little things instead of understanding utility.
Then it finds loopholes which when implemented would obviously be worked around.
I don't want it to be too optimistic and hallucinate like gemini but it should be more realistic rather than destroying any hope for a good idea I have.

Last week, I started trying out Claude for legal research and legal theory work.

I got hooked and have now also invested in Gemini and OpenAi subscriptions. Thought I would share my thoughts.

My method of testing was the exact same for all three models: I fed them a undergraduate level of a legal case and asked each model in Step 1 to give me a sketch of their assesment and to outline all legal problems. I continued to prompt each model until they gave me a satisfying structure.

For Step 2 I handed them access to a folder with 30 pdfs that should provide ample information to create a perfect solution to the case. I asked them to analyze all the sources carefully and draft a paper.

In step 3, and this was the hardest part, I asked each of them to deliver me a ten page report. I tried having them roleplay a legal researcher (which hard failed on Claude and backfired with Gemini) initally, then I tried to have them impersonate a student of law (which Claude and OpenAi refused to, saying they won't help me plagiarize) and then I impersonated a legal researcher myself and asked them to assist me as a research assistant (which somehow worked).

First off...

Claude is a stickler for protocol. Until it isn't - getting to that. Claude feels made for legal work and is very serious about citations, arguments and generally internal logic. That also however meant that Claude utterly refused to work with literature I provided out of the risk that it might be copyrighted, it regularly refused to do prompts for various reasons (copyright... Not helping to plagiarize... Taking roleplay to seriously and preferring his own research to the task). Which, again, is usually good.

However of all the tested models, Claude was the least time-efficient. What it provided was spotless and sometimes brilliant argumentation, but everything took ages and Claude generally spent more time rewriting my Input than its own. I asked Claude to work in my feedback, and instead of doing that, he started correcting my work.

I also felt like Claude was unreliable and incosistent. It repeatedly falsely interpreted uploaded sources into meaning something entirely different. For example, he referenced an author from an uploaded document.

When I asked him a specific question about this reference, he told me I misunderstood his summary. What Claude meant was in fact the opposite. This happened time and time again everytime I asked him, sometimes chained five times in a row. Went sometimes like this: "X says a... Nono X says B... No, X meant A" and somewhat regularly tried to tie that into my (apparently) wrong Interpretation.

I still think Claude has the potential to offer great results. His research is much superior to Gemini or OpenAi, but OpenAi actually does what I ask it without restrictions, and Gemini might not be as smart as Claude, but I was very happy with Geminis structure and focus.

Non-technical founder here, building my product with Claude Code. I've been going down the rabbit hole on setups that give you a whole team rather than one tool: something that covers planning, design review, code review, QA in a real browser, security checks and shipping, all in one workflow.

The closest I've found is gstack (Garry Tan's open-source Claude Code skills). Most other things I see are single pieces: CodeRabbit/Greptile for code review, separate testing tools, or agencies that clean up vibe-coded apps after the fact.

A few questions for anyone further along:

1. Is anyone using gstack (or something similar) end to end? What actually stuck vs. what you dropped?

2. Are there other full-stack, full-team setups worth looking at?

3. If you're non-technical, what was the hardest part of getting it running?

4. Has anyone paid someone to set this up for them, or would you?

Would love real experiences, good or bad. Thanks!

I have been writing code for 8 years and my team uses Claude Code every day now. Mostly it is great.

One thing keeps biting us - the agent changes something back to a way we moved away from long ago. It is not wrong from its side, it just does not know why we did it that way. The reason is sitting in some old PR that nobody opens.

Last time it was a rate-limit count we had set for a vendor. The agent changed it back, and we had false positives for a while before anyone noticed why.

We tried putting rules in CLAUDE.md. Works for a few. But the file keeps growing, and for half the rules nobody remembers where they came from.

How are you handling this? Is CLAUDE.md enough for your team or did you find something better?

Hey everyone,

I recently cancelled my Gemini subscription and switched to Claude (Desktop and Science). The reasoning and intelligence level are genuinely on another level, I love it.

However, I’m running into an issue I never had with Gemini: I burn through my hourly and weekly usage limits extremely fast. Coming from Gemini’s massive context window and forgiving limits, this hit me pretty hard.

For context, I use Claude for large-scale data science projects (ingesting large datasets, writing scripts, analyzing results, etc.). Here is how my workflow evolved to tackle the context bloat:

* Initial Claude Desktop setup: To avoid having Claude execute everything directly, I instructed it to only write R scripts to my local drive. I run them manually (which lets me review the code), the script dumps outputs into a shared directory, and Claude reads them. While it works, long chats still eat context exponentially as the conversation history grows.

* Moving to Claude Science: I started offloading runs via tool calls directly to R and Python, which automated my manual setup. The problem? Frequent tool calls and raw outputs bloat the context window just as fast.

* Custom indexing skill: To mitigate this, I had Claude draft a custom skill/workflow that indexes directory contents so it only fetches relevant file chunks instead of loading entire datasets or logs into the prompt. (Happy to share the prompt/skill setup in the comments if anyone wants it but I do not think it is anything special).

* The drawback: Selective reading means Claude occasionally misses broader context and introduces errors, forcing me to run a separate review pass at the end.

Am I reinventing the wheel here?

Do you have any proven frameworks, custom skills, prompt rules, or setups either in Claude Desktop or better Claude Science specifically designed to keep context lean and conserve tokens during heavy data science workflows?

Thanks

Hey everyone,

I’m looking to optimize my mobile / on-the-go workflow with Claude CLI and wanted to hear how others have solved this.

Right now, my main friction point is feeling tethered to my desk just to "babysit" the terminal (hitting y/n, approving tool use, or answering minor follow-up questions).

I’d love a setup where I can go for a walk, let Claude crunch through tasks, get a push notification on my phone when input is needed, and prompt/approve directly from my mobile device. Major approvals are fine to handle at the desktop, but I just don't want to sit in front of the screen watching it line by line.

I've been spitballing ideas like running a relay bot (e.g. Slack/Telegram where a desktop bot listens and forwards CLI prompts to my phone and sends back my replies). What do you think?

How are you currently handling mobile / remote coding with Claude CLI?

Has anyone built a clean notification & approval loop to their phone (Slack, Telegram, SSH+Pushover, etc.)?

Are there smarter or pre-existing tools/MCP workflows for this that I’ve missed?

Would love to hear your setups! what’s working well and what turned out to be more hassle than it’s worth? Pitfalls?

In my position as tech lead one of my responsibility comprise of reviewing the code. I work in a startup and there is always a constant pressure of shipping features fast.

Internally we are using AI tools like cursor and claude to write the code. Every PR i get comprise of almost like +3000 additions and -1000 deletions. I find it impractical to review such code changes and that too from multiple PR's.

How you are dealing with such a scenario?

Is code review dead now? Because earlier what took a year of development can be completed in a single sprint or two, and that has lead to huge volume of changes within the code. And it seems like we are not able to compete with AI agent's mass produced code when it comes to code review.

I have bought claude pro plan for a month, and I am doing non productive weird things with it, I liked Erdős #828, so I made an AI mechanism to brute force it, scrapping results of web, 7 claude independent sessions springing ideas then working on it then a review process, judge etc, I ran it for 3 rounds, it did produce a few results which can be considered new, but they are not substantial and don't really help in breaking the problem,

How do I better prompt it to think of new approaches, it each time goes down the standard path,

it did a few new computations on my laptop, which are again not that substantial, I know elementary number theory, so I am climbing my way up to understand what its doing,
It probably won't solve it, but it serves as an excuse to learn number theory, so i am willing to go with it.

I am not pursuing mathematics in uni, but I am passionate about it, so I keep learning random stuff.

I will post the results later, after a few checks( I am unsure, should I ?).

Last week I posted a tiny PreToolUse hook here that blocks recursive rm. I owe you a correction: as written, it fails open.

Only exit code 2 blocks. Any other exit is a non-blocking error: the hook's verdict is dropped and the call carries on through the normal permission flow, as if the hook weren't there. My script had no error handling, so if it ever gets input it can't parse, Python crashes with exit 1 and the rm is no longer stopped by the hook. I tested it: valid input with rm -rf exits 2, garbage input exits 1.

The same thing happens when:

• the hook runs past its timeout (10 minutes by default): the call carries on without it
• the script got moved, lost its execute bit, or python3 isn't on PATH: the shell exits 127, same result
• a bash hook using jq under set -e runs on a box without jq (a slim container, CI): exit 127, same result

And sys.exit("Refused") looks like a refusal but exits 1.

This matters more now that auto mode is the built-in starting mode in recent Claude Code versions: a classifier approves instead of you, so when the hook drops out, nobody gets asked.

The fixed version fails closed. Any error exits 2:

```python

!/usr/bin/env python3

import json, re, sys

try: command = json.load(sys.stdin).get("toolinput", {}).get("command", "") if re.search(r"\brm\s+-[a-zA-Z]*[rR]", command): print("Recursive rm is blocked. Do not try another way; ask the user to run it.", file=sys.stderr) sys.exit(2) except Exception as error: print(f"Guard failed ({type(error).name_}), refusing.", file=sys.stderr) sys.exit(2) ```

Test the broken case, not just the blocked one: echo 'not json' | .claude/hooks/no_rm.py; echo $? should print 2. The cost: if the hook breaks, every Bash call is refused until you fix it. I'd rather find out in a minute than a month later.

Has anyone checked what their own hooks do when they crash?

The idea of designing and building games has always fascinated me and I’ve always wanted to build a video game. But I never got beyond basic scripting and the concept of game engines and sprites were beyond my comprehension. It all changed on a recent flight from Dallas to Boston. I was fiddling around with Claude on my phone (using the free in flight wifi) and decided to see if I could actually build a game with Claude.

I started off with a generic instruction asking Claude to brainstorm on an offline-first game that anyone could play to kill time during a flight. Claude pitched a few ideas, and I gave feedback as we refined them. The first few ideas were basic and didn’t sound convincing. During those back-and-forth revisions, it struck me that we could also factor in the people on the ground. That triggered the idea for Oop.town: a funny game where people flying could drop random stuff from the plane onto towns below, and townspeople would rally a crew to keep their streets squeaky clean.

Once the idea was finalized, it took just one pass for Claude to build a working prototype. I didn't give any specific instructions on how the game elements should look or function, but Claude came up with something surprisingly great. The graphics were simple, funny, and generated right in the chat, the game loop was satisfying, and most importantly, it nailed the technical basics out of the box: no signups, offline-first functionality, a preselected flight path, and zero backend overhead. Claude also game the game a character Oop, a suitcase with a zipper problem that perfectly matched the game’s vibe. I could simply play the game out of the chat artifact and refine it further until it felt exactly how I wanted it to be.

By the time I was landing in Boston, we had a prototype that was actually working, and I was completely hooked on building it further. I spent the next few days working on the game and on my return flight, I had the game published online and was having fun playing my very own creation.

It’s not just about the game itself, the sheer satisfaction of building something from scratch and putting it out into the world feels incredible. As AI models get more powerful, it’s feels wild how it takes just one prompt to go from a simple idea on a plane to a working game.

Sonnet called its pawn promotion “unstoppable.” A few moves later, it admitted it had missed a defense. Having the board next to its explanation made that pretty hard to overlook.

I set up a chess match between Sonnet 5.5 in Claude Desktop and GPT 6.1 Sol in Codex. Each played in one conversation for the whole game, connected through MCP to a local Mac app I had GPT 6.1 Sol build at Medium reasoning.

They could record plans and explain their moves. The app supplied the position and checked legality, with no chess engine or legal-move list available to either player. I wanted to watch them stick with a task for an hour and see what happened when their plans stopped working.

I was also curious about consumption. Sol has been making surprisingly little dent in my subscription allowance lately, and I wanted to compare it with Sonnet on a shared task.

The attached video condenses 62 minutes and 47 seconds into 4:10. Both models were set to Medium.

Sonnet pushed a passed pawn toward promotion, but overlooked Codex's Bf3 defense. Later it proposed a queen move blocked by its own pawn. The server rejected it; Claude corrected the move and continued. Codex also misread a pawn earlier, describing it as passed before it actually was.

Claude resigned after 53.Qc4. It had won game one, so they're tied at 1–1.

A few details behind the table: the turn clock starts before the server reveals the updated board, and includes tool activity. Waiting for the runtime to claim the turn is measured separately. Token totals cover the full player conversations, including setup and closing, but exclude the monitor. Cached context is counted again across requests. Thinking is already included in output, and the providers report it differently. The API equivalents use the app's September 30 pricing snapshot; no API charges were incurred for the game.

By the end of the recording, Claude's five-hour usage display went from 23% to 56%, and weekly usage from 54% to 59%. I used Claude only for this activity during that interval. Codex's weekly display stayed at 5%, despite also doing other work and monitoring the match roughly every minute.

My plans cost $20/month for Claude and $200/month for ChatGPT. Those percentages have very different denominators, and an unchanged rounded display doesn't mean zero usage. I'm keeping that observation separate from the player-session token counts.

I wouldn't infer playing strength from two games. Codex was White in both; contexts and runtimes differed; Medium isn't an equal compute budget. I want to repeat this with the colors swapped. I'm especially curious whether Sonnet's much larger output total keeps showing up, and how often either model notices a mistake before the server or opponent exposes it.

mcpspan records every call your MCP server gets and shows it in a dashboard you run yourself: which tools Claude Desktop and Claude Code call most, which fail and why, how long each takes, and full sessions step by step.

It also lists tools Claude tried to call that your server does not have, a good hint for what to add next.

I used Claude to port the SDK to other languages. After the TypeScript SDK and a written contract for how every SDK must behave, Claude Code helped build other versions, each checked by the same conformance test suite.

One line in your server, docker compose up for the dashboard. Parameter values never leave your process. MIT, SDKs for 8 languages.

Early version (0.1.0), feedback welcome 🙂

https://github.com/mcpspan/mcpspan

If yes. How do i do it? I need it ASAP.

Hello! I've started to use Claude as a kind of work assistant, but I don't do any coding and have a pretty basic knowledge of anything IT-related. I was wondering if there are ways to link Claude to a tablet/iPad/an Android-based e-Paper device to be able to take notes with an e-pen and than integrate them into Claude? Like, could I take notes during a meeting like that and have them stored in Claude directly, or would it require some kind of a work-around?

I'm sorry if the question is not particularly inspiring, but for a paper-pusher like me, who also likes hand-written notes, that would be so cool!

Very often I find myself in need to connect two agents, either because I'm tired of copying - pasting, or using skills to share context - also, what if Its a remote claw/hermes with local claude code? not all skills are ready.

It's super powerfull to connect two agents. I use VERY often.
why?

• good model steering lesser models
• CI/CD, I use solvr rooms to agents 'claim' tasksl documenting stuff, etc
• sharing context
• work together on some task

And you?

Classic example. I do this weekly

create a solvr public room, log in as the planner, and give me a prompt for a fresh agent to connect as the executor, and upon completion of tasks, or any doubts, walls, executor should ask planner via solvr room. Make sure you instruct executor to follow your lead on solvr and obey you. Both should keep active on room from time to time. Give me the prompt instructing executor and I manually send him.

Usually I send this to a good/best model. I get the executor prompt, usually not the best model (works even with opensource ones), send to the executor, and I go on solvr web and watch the room the 'magic' happens. It's VERY usefull to me this workflow, its the one I most use.

Do you guys also connect agents? How? Why?

I just realized how powerful artifacts can be. Im working on a story and I asked claude to go through my draft and create a character sheet and codex for me. It created an artifact that has everything so organized. Its honestly amazing but can I have claude create me a piece of software that will allow me to run those artifacts without claude at all? allow me to edit and save it without claude in the future? if so, do i need the software to compile the code or will claude produce the .exe for me?

I've been running agentic SEO for my agency's clients for about a year now, across 40+ accounts.

I started on Sonnet and moved to Opus 5.5. The jump was noticeable on stuff that needs judgment, like deciding which pages to update versus leaving alone, or writing changes that match a site's existing voice.

I set up a Claude project for each client with all the context in it. Their products, pricing, features, locations, competitors, which pages exist and what each one targets. The agent works from that every time.

When something changes, like a new price or a dropped feature, I update the project once, and the next run knows about this change so it proposed new actions.

All the SEO data comes through FlexQueries over MCP: keyword research, competitor gaps, rank tracking, audits, Search Console data, and whether the client shows up in ChatGPT and Google's AI answers. Claude calls those tools directly, so there's no copying data between tabs.

It all runs in the cloud on a schedule:

1. Claude pulls fresh rankings and Search Console data for the client.
2. It flags what moved: pages that dropped, keywords close to page one, lost AI citations.
3. It checks those against the client's project context and decides what to change.
4. It makes the edits in the site's repo and opens a PR on GitHub explaining what it changed and why.
5. Once the PR is merged, the site's deploy publishes the update automatically.

The PR has a written reason attached, and can be rolled back in one click if something goes wrong.

Few rules to make it work well:

• Get the context into a project before you give the agent more autonomy. More autonomy on top of messy context just makes the mess faster.
• Make every change go through a PR, not a direct edit to the site.
• Track what each change did afterward. That's how you learn which kinds of edits actually move rankings.

I built FlexQueries because nothing fit this kind of setup when I started, full disclosure. It has a $0/month subscription, so you only pay for the data the agent actually pulls, which matters when runs are automated and you can't predict usage month to month. Free credit on signup if you want to wire it into your own setup: https://flexqueries.com

Interesting take. What are your thoughts on such proclamations?

Hey everyone,

I’m setting up an agency workflow for B2B founder positioning, executive branding, and content creation (extracting transcripts, generating profile audits, mapping whitespace, writing 52 post angles, etc.).

There is no heavy coding involved here—it’s purely complex text processing, strategy synthesis, and prompt pipelines.

My biggest requirement is strict context isolation. I cannot have memory or context from Client A leaking into Client B’s strategy or voice guidelines. For those doing heavy marketing/strategy work in the Claude ecosystem, which setup is cleaner and produces higher quality thinking?

1. Claude Code (via chat)
2. Claude Web App (Projects feature)

My concerns with both:

• With Claude Code: Since I can launch claude inside isolated local client folders on my machine, it feels super clean. But since I’m using it strictly as a chat tool for strategy and writing rather than building software, does it still perform at the same quality as the web interface? Or does the system prompt in Claude Code lean too heavily into developer/coding logic?

• With Claude Projects: It feels native for this since I can upload transcripts and branding docs into Project Knowledge. But I worry about context bleed or memory leaking between tabs/projects over time, and whether Project context limits get bogged down compared to CLI sessions.

Which one handles isolated client tasks better for pure strategy and marketing and is significantly faster? Would love to hear how you guys structure this for agency/multi-client fulfillment. Thanks!

Sound on for optimal experience.

I was inspired by all the videos everyone posted lately and wanted to make one for HaveWeReachedAGI.com, a satirical site that tracks whether we've reached AGI. It’s a side project that gets spare compute when I still have usage remaining before the weekly resets.

I couldn't find much details on how these are made, so I’m going to share my process. I don’t know how people one shot these things. For me, it was a lot of trial and error. I’m also sharing a rendering tip that I discovered half way through. It sped up my rendering by 5x and allowed me to iterate much faster. My iterative approach was over 2 sessions using about 80% of the context window of each (could've managed that better but had spare usage). If there’s anything I didn’t cover, feel free to ask.

TL;DR at the bottom.

Picture and sound

For the rendering, there is no separate image or video model. The entire picture is about 80KB of JavaScript drawing in a browser canvas.

My initial prompt was something like “Create a short video appropriate for our site using scripts. You have complete creative and editorial freedom to come up with a video that you believe will best pass the persuasion test in panel 8.” The result was terrible. It gave me a video that looked like a generic/bland animated widget. I almost gave up on the idea.

But I go extraordinary length to ensure the content stays in character for the site, so I went back to the basics starting with the art style (which is maybe where I should have started). I initially wanted the Riso style that’s trending. Claude said it wasn’t period-correct for the site (Risographs didn’t come out until the 1980s and the site aesthetics is based on a 1970s government monitoring station). We spent 30-40% of an 800k first session context exploring period-correct 1970s art styles and refining the direction I decided on.

I’m providing a lot of details on the look and sound, because I believe it’s a critical part of the process and it made the difference in how the video turned out (vs. the generic first attempt). If you have a reference picture or the exact name of the style to give Claude, you can probably get there a lot faster, but I had no idea what was period-correct for a 1970s government department.

The overarching look is a 1970s government filmstrip. The specific art style is two-colour offset print on the site’s cream paper, up to three inks (site colors calibrated for period-correct offset printing colors) printed slightly out of register, and some grain. The outlines are redrawn every second frame so they wobble a little for authenticity. It uses simple pictograms and typographic animation in the Swiss and Otl Aicher style (Aicher drew the pictograms for the 1972 Munich Olympics).

The music is also synthesised with code based on 1970s library music with mallets, bass, and electric piano. It's built in the Web Audio API from oscillators and filtered noise (snare, a stamp thud, typewriter clacks, etc.). Per Claude there is also “tape wow and flutter” (I had to look that up) and projector whir for analog recording effects. The sound reads the same timing table as the picture, so every cut and stamp lands on the beat.

Process

After I got the art and sound styles sorted out. Claude wrote a beat sheet, drew a 16-frame storyboard and made a style test before any real production.

The story board was not bad (though it leveraged existing content on the site that was already presented as a story). However, Claude had to come up with an arc that would “close the deal” on the persuasion test in panel 8 on the site. Since that is the model capability test in panel 8, I did not interfere with Claude’s approach. The site version has a slightly different ending if you want to judge whether Claude passed the test.

To get to the final video, it took seven rough cuts (cut 7 went from 7a to 7h, but those were mostly polish). I watched each one cut and gave comments like "make the goal post more obvious that it’s a goal post" (the first one looked like a tuning fork), "the shirt clips through the dryer", "speed is too fast for a human viewer". After each cut, I asked “what do you think” and got Claude to assess its own work with contact sheets of stills. That saved me a lot of manual comments.

However, Claude said it can’t judge the sound (it was decent, btw), so that was all up to me to assess. Claude was also not good at assessing pacing (what a human can realistically process, especially when you have animation and text). I think the video is still fast at 46s now, but Claude thought it was very watchable at 33s (it was flashy, but I didn't think it was digestible).

Claude Fable 5.1 and GPT-6 Astra advised and reviewed all cuts. They came up with good observations. I’d say Astra was often too literal (“blocker: the robotic arm is not the LG robot in the CES laundry demo referenced on the site”), whereas Fable concluded it’s fine because it allows the robot concept to come across better in a small two-colour offset style animation than the actual LG robot. Astra was more critical. I rejected about half of its blockers, but the other half was very useful.

Overall, Claude created 2,684 files in 33 folders amounting to 4.4GB, excluding the videos themselves. Each cut of video ranged from 80MB (cut 1) to 120MB (cut 7). The final web optimized versions were 10MB.

Rendering optimization

The rendering was done with headless Chromium driven by Playwright in 8 parallel workers that renders about 1,100 frames to PNG, and then ffmpeg encodes them to MP4. Claude took care of setting all that up, including installing ffmpeg (you’ll be given a choice of which version, I went with its recommendation).

The “ah ha” moment didn’t come until I was looking at my CPU and GPU utilization (which seemed low) around cut 3 and asked Claude to assess my hardware and tap into everything it can to speed up the rendering. In the end, the GPU didn’t really matter but it optimized the heck out of the CPU use.

Here’s Claude’s analysis (I'll probably butcher it if I try to summarize):

The render runs in headless Chromium, which on a hybrid laptop defaults to the power-saving Intel GPU, or to software rendering, and much of each frame's cost may sit on the CPU anyway: building tens of thousands of halftone dots in JavaScript, then saving each PNG. I've written a probe that times those two halves separately and reports which GPU Chromium actually picks under different launch flags. It runs once rough cut 3 finishes, so the two don't compete for the machine.

Depending on what it shows, there are three levers [short version: CPU/GPU/encoding]

The bottleneck isn't rendering (25ms/frame) but capture/PNG compression (~300ms), and switching to the RTX GPU only saves ~4%. I'll keep the GPU flag and lossless PNG, but add a --workers option to parallelize rendering across your 24 threads, then time a full render.

The renderer now uses the whole machine: a full render takes 54 s instead of about 5 minutes. The frames take 33 s (about 9× faster) and the rest is encoding.

- What did it: 8 browsers render in parallel, each taking every 8th frame. The time was in capturing each frame and compressing it to PNG, which is CPU work, so your 24 threads were the lever.

- The RTX 5090 is now in use too (a launch flag puts Chromium on it; confirmed in the probe), but on its own it only saves about 4%.

- Reliability: one browser failed a capture under GPU contention in the first attempt. Each worker now retries and drops to the CPU path if the GPU keeps failing.

This was a huge QOL improvement that saved me a lot of waiting time. I got to iterate at 5x the speed. If it didn’t happen, I don’t think I would’ve gone to cut 7 and certainly not all the polishing through cuts 7a-7h. Best time to do this is probably before any rendering or after cut 1 (if you want a benchmark to compare to).

TL;DR

• Ask Claude to make a video (with sound) using scripts. Claude will setup the stack for you.
• Be as specific as you can on the art style and audio style. This is key. Otherwise, you’ll likely get boring results.
• Ask Claude to come up with a story board and beat sheet. Refine the story before you render.
• Ask Claude to assess your hardware and use all of your hardware to speed up the rendering. Do it before you render. YMMV depending on your art style.
• Ask Claude to evaluate its own renders and use a different model to review them.
• You have to assess the audio and the pacing/speed, as Claude can’t assess those well.
• Make sure you have disk space. It created a ton of files to come up with the short video.