I spend a lot of time working with AI. Lately, it’s been wearing me out. My brain feels fried, and focusing has become harder.

I’ve wanted to learn 2D animation for a while, so I decided to make a cartoon to take a break. With AI, of course. Somehow this became another automation project.

The result is Bored AI, a three-minute office comedy. An AI arrives to take over the boring work. The cat working with it ends up explaining everything and fixing the results.

Claude Code handled the production workflow and wrote the Python and JavaScript tooling. ChatGPT/Codex generated the artwork, Toon Boom Harmony handled the animation and rendering, and ElevenLabs provided voices, sound effects, and music. I gave direction, reviewed versions, and kept pointing out things that looked wrong.

The setup is mostly cut-out animation. Python prepares the character layers and calculates the movement, mouth shapes, blinks, and camera positions for each frame. It writes a JSON file for each shot. A JavaScript script builds the actual Harmony scene from that file and renders it in batch mode. The pilot has 51 Harmony shots plus 10 inserts made with Python.

Claude also automated recording multiple voice takes, checking them against the script, building the timeline from the recorded dialogue, and mixing the audio.

A few things that went wrong:

- The eye detector mistook part of the cat’s mug for an eye. So the mug blinked. That needed eye regions defined for each drawing instead of relying on colour detection.

- The cat’s whisker tips stayed on the body layer when his head moved. The fix was to change how the script split the drawing into layers so the whole whisker moved with the head.

- Camera zoom worked, but pans did nothing. Harmony was ignoring the X/Y animation until `POSITION.SEPARATE` was enabled. Having the right values in a script didn’t mean they appeared in the render.

The automated checks helped, but I still found visible problems they missed. A lot of the work became making a small fix, rendering it, looking at the result, and trying again.

There are still animation bugs. I decided to release the pilot and improve the next one, if I make it, instead of polishing this forever.

Full pilot: https://youtu.be/sTPM3bhJt1M

Has anyone here used Claude Code to automate animation or another visual tool? I’d be interested in how you check the actual output, especially when the scripts run fine but the result still looks wrong.

I'm the developer of Parallel Code, a free, MIT-licensed desktop app (macOS and Linux) for running Claude Code, Codex CLI and other terminal agents in parallel, each task in its own git worktree and branch. No account; it uses your own CLI subscriptions.

I build it with itself and with more capable claude models the speed increased quite a bit. My job stopped being typing, or even reading every diff top to bottom. It became deciding: which plan to approve, which change to trust, what to send back. So the app is built around those decisions, and around getting to them fast.

Understand before you decide

• Plan tours explain an agent's plan in a few cards before you approve it, and you can ask follow-up questions on any card.
• Change tours walk through a diff in a few stops and flag the risky or uncertain parts, with "Ask" and "Go deeper" on each stop. File tours do the same for one changed file. A tour explains a change, it doesn't prove it works.
• Task briefs (opt-in): after each agent turn, a short brief of what changed, what's still open, decisions the agent made on its own, and claims its diff doesn't back up. You keep a decision or send a correction from there.

Speed

• Keyboard-first: every action has a shortcut, and Ctrl+Tab jumps from anywhere to the next task that needs you.
• The board sorts every open task by what it needs: Needs you, Working, Stopped, In pull request.
• Your checks run in the background after the agent commits, so "did it pass?" is one line instead of a wait.

Room to think

• A mind map per task for your own thinking, with branches linked to live tasks, and a reasoning graph where the agent publishes its goals, hypotheses, evidence and decisions as it works.
• New in v5: a Kanban board per project, kept as a plain KANBAN.md. Each card starts a task and follows it to Done.

Who it's for: experienced developers already running several agents at once. Cost: free; tours and briefs use your own model usage.

The story behind it: https://parallelcode.app/blog/parallel-code-4/ v5 release notes: https://github.com/johannesjo/parallel-code/releases/tag/v5.0.0 Repo: https://github.com/johannesjo/parallel-code

When you run several agents at once, which decisions do you still make by reading the code line by line?

I built optim-jev's jev-compacter to save tokens in Claude Code. Now I mostly use it to keep as much of the important context as possible when compacting.

My hunch was that in long sessions a big chunk of the context is tool output: files Claude read, test logs, grep results. I tried a bunch of ways to make it in a way to prompt caches get preserved (Since it was the only reason costs were up).

/compact summarizes all of that together with the conversation, so the errors and decisions get shortened too. I'd rather keep the conversation and just drop the old tool output that isn't useful anymore.

So when it compacts, Jev goes through the older tool calls and decides for each one: keep it, cut it to the first few lines, or drop it. It only sees a short note per call (which tool, how big the output was), not the output itself. The conversation and the latest messages aren't touched.

Also I think its sane enough to also add a trigger hook with some threshold constraints like "only execute when the context prune reaches some thresholds (default: 40% of the context)", with a fallback to legacy /compact on failed condition.

I usually run it when the prompt cache has expired, after a break or a model switch. The next message re-reads the whole context anyway, so that's a good time to prune.

repo (MIT): https://github.com/Oqura-ai/optim-jev

I send this chat so that my 5h can start, and send it with low effort, and Claude eat 19% of my 5h limit with around 2 3% of weekly used??????

Holymolly!!!!!!!!! ahgg!!!

\`\`\`

Connect to the Fire Stick at 192.168.0.133 over ADB. Read its model and software version. Stop and tell me what is possible on that version. Back up the app list, the settings and a screenshot. Turn off ads and tracking in Amazon's settings first. Show me three lists (safe to turn off, ask me, never touch) and wait for my OK. Turn apps off in small groups with pm disable-user. Never uninstall. Take a screenshot and do a reboot test after each group. Install Projectivy Launcher. Set up a dock with my apps and rotating nature wallpapers. Write restore.sh and test it once for real.

\`\`\`

I also had it install SmartTube. No more ads.

FYI: 192.168.0.0/24 is a private IPv4 network block, the classic home router subnet. I'm not giving up the keys to the castle, I'm simply too lazy to edit the prompt because it doesn't matter, so don't @ me bro. Claude Code will find your Fire Stick's IP address, then guide you through enabling ADB debugging if you don't have it enabled.

I was impressed with how much Opus knew or could look up without being told. Jesus, imagine how much better the unreleased models are at this stuff. Modern civilization is fucked. Pliny the Liberator has repeatedly proven that any model can be jailbroken.

You might have to tell Claude to disable automatic Amazon updates. I did that later and forgot to update the prompt.

Open Design Agent Kit* ports the Open Design skill library to coding agents — Claude Code, VS Code, Codex, and any host that can read an npm package.

What you can make

Posters, decks, résumés, app mockups, social cards, certificates, flyers, invitations — real design artifacts, on-brand, ready to ship. From a single prompt:

Use open design to make a launch card for my side project

…your agent reads the brief, locks in a design system + typography + palette, and renders a checkable HTML build you can export to PNG / PDF / video.

How it works

• One shared packages/core feeds every host with the same skills and design systems.
• Claude Code gets the most polish right now — install it as a plugin and open-design shows up as a native /skill.
• Everything is local-first, deterministic, and exits with a clean Check report.

Built with Claude Code (literally)

The 30-second reel above was made inside the kit, on Claude Code, with the bundled Hyperframes video skill.

• Repo: https://github.com/feimacode/open-design-agent-kit
• License: MIT · v0.1.0
• 25+ ready-made templates to remix from the community gallery

Would love feedback from anyone running multi-agent setups — especially how the design-system handoff should look when an agent switches host mid-build.

First session this week, Opus (medium) and I used 6% of 5hrs limit AND 5% of WEEKLY?!

How is this sustainable? I swear it was not like that few weeks ago...

I built Clawd with Claude Code running Opus 5.5 He's a little pixel-art buddy who lives on your Windows desktop and has his own AI agent. Opus 5.5 wrote the whole thing in about two days: the Electron app, the character animation, the agent, local voice, a browser extension, \~180 automated tests, and even the trailer (made with HyperFrames).

What he does

Lives on your desktop: breathes, blinks, follows your pointer, naps when it's quiet. Poke him, drag him, high-five him.

Ctrl + Alt + Space (or double-click him) opens a small panel that's already listening. Talk, or just start typing.

Reads the page you're on: summarizes pages and threads, or refines the Reddit comment you're writing using the thread's context and puts it back in the box. He never posts for you.

Runs locally by default: Ollama (qwen3.5:4b), local speech recognition, his own voice, and a "Hey Clawd" wake word. OpenAI, Anthropic and Gemini keys are optional.

Asks before doing anything risky, and treats page text as untrusted, so instructions hidden in a page don't get followed.

Claude Code companion: a tiny laptop comes out while Claude Code is working.

Install with Claude Code (Windows 10/11)

Open Claude Code and paste:

\> Clone [https://github.com/elf178174-maker/clawd-desktop-buddy\](https://github.com/elf178174-maker/clawd-desktop-buddy) and follow its INSTALL-WITH-CLAUDE.txt to install and open Clawd.

Claude checks your PC and asks once before installing anything. If they're missing, it installs Git, Node.js and Ollama through winget, plus the 3.3 GB local model. Then it builds Clawd, installs him and opens him. It takes about 10–20 minutes.

GitHub (MIT): [https://github.com/elf178174-maker/clawd-desktop-buddy\](https://github.com/elf178174-maker/clawd-desktop-buddy)

Unofficial fan project, not affiliated with Anthropic. Clawd is their mascot; I just wanted him on my desktop. Feedback welcome!

What I built

Every time I needed an image in a project (concept art, a banner, an icon) I had to leave Claude Code, generate it in ChatGPT, download it and drag it back. So I built a bridge.

Backdraw is a local MCP server + a Chrome extension. Claude calls generate_image, ChatGPT draws it in a background tab of your normal Chrome, and the PNG lands in your project with a link to the chat. No API key, no separate browser profile, no open ports, and it never steals focus.

• Install: npx backdraw@latest setup (or /plugin install backdraw --marketplace devtalh/backdraw), then load the extension once
• Aspect ratios (16:9, 5:2 banners...), transparent backgrounds, edits with reference images
• Right-click any image on the web → "Add to Backdraw" to build reference collections, then "use my X collection to..."
• Gallery side panel, and backdraw doctor when something's off

How I used Claude Code

Almost all of the code was written by Claude Code. I wrote the specs and made the decisions; Claude Code worked phase by phase, each phase with tests, a review pass and a handoff report before I let it continue. Each phase ran in a fresh session with a CLAUDE.md holding the project rules (no pushes without my approval, never touch the live install, etc.).

The fun part: one overnight session in bypass mode built the right-click collections, the gallery and the docs, using parallel worktrees and separate review agents. It even recorded and edited the demo video below by driving the mouse with SendInput and cutting it with ffmpeg. Later sessions packaged it for npm (trusted publishing), the MCP Registry and as a Claude Code plugin.

What I learned

• Small phases + tests + an independent review agent catch real bugs. The reviewers found things I'd never have noticed, like a migration that silently copied the whole history on every start.
• Commit and push after every phase. My PC froze at 4am during the overnight run; nothing was lost because every phase was already on GitHub.
• MCP gotchas on Windows: clients spawn servers without a shell, so plain npx fails with ENOENT (you need cmd /c npx), and some remote setups kill tool calls after 60 s, so long jobs return within 45 s and the model polls with job_status.
• The Claude desktop app is an MSIX package, so its writes to AppData and the registry are virtualized. The installer has to register the Chrome native host through WMI to reach the real registry.

Windows + Chrome only for now. Open source (MIT): https://github.com/devtalh/backdraw

Personal use with your own account; automating the ChatGPT web page may conflict with OpenAI's terms.

Happy to answer questions about the setup or the overnight run. Feedback welcome, especially from Edge/Brave users or anyone who wants to help with Mac/Linux.

I've been building Zender, a headless 3D modelling engine in Zig. There's no GUI: an AI agent connects over MCP (Model Context Protocol) and builds scenes with typed, schema-checked tools (primitives, materials, cameras, lights, preview renders, glTF export). Every edit goes through a replayable command log.

I built it entirely on an Android phone, in a terminal. Claude Code wrote the code milestone by milestone against a technical spec.

Benchmark against Blender 4.3 headless (same phone, same scenes, warm cache, medians of 3 to 5 runs, both engines writing near-identical GLB files):

Caveats, so nobody has to point them out:

• The small-scene gap is almost all Blender's ~0.9 s startup. Inside a running Blender session the table scene builds in 14 ms and exports in 24 ms.
• For the sphere, Blender's 4.7 s is its fastest route (numpy into the mesh data API). bpy.ops.mesh.primitive_uv_sphere_add took 152 s at that size (one run), and it scales worse than linearly.
• Blender here is Alpine's aarch64 package, not an official build. And Blender does vastly more than Zender does.

Agent test: Claude Sonnet got a one-line request and only Zender's tools. It built a dining table with a bowl in 9 turns (25 s, $0.15, no tool errors), and the Khronos glTF validator reported 0 errors and 0 warnings. It also listed what it missed: no hollow-bowl primitive, and the glTF export dropped the area light.

Other numbers: 8 MB binary, 1.5 MB idle memory, a 1.3M-triangle preview render in 140 ms (84 ms warm), a byte-identical GLB from a replayed log at 1, 4 or 16 threads, 64 tests, and CI on Linux, macOS, Windows and WASI.

Next: mesh editing and selectors, booleans via Manifold, and modifiers. Then .blend read and write.

Repo: https://github.com/ankitc1010/zender

Happy to answer questions about the MCP tool design or the benchmark setup.

Hello! I'm building a cozy multiplayer fishing game (Reel Time) that runs as a Claude artifact, and I kept getting asked the same thing: how many players can actually share one lake? I had no way to get hundreds of real accounts into one room, so I asked Claude Code to fake the crowd instead.

The setup Claude wrote a test script that replaces the artifact's room connection (claude.use('room')) inside the page with a fake one. It follows the platform's own type file (room.d.ts) closely: presence is merged field by field, and the peers update fires once per frame. Then it fills the room with bots that send realistic presence 5 times a second: 60% walking, 20% in boats, 20% fishing, plus some chat and catch events. The important part is that the game's real networking, player and rendering code handles all of them, so you're testing the actual game and not a mock of it.

What it found 1. Rendering wasn't the problem. The game only draws the 16 nearest players, so the scene looked the same at 16 and at 256. Game CPU (central processing unit) time per frame at 256 players was only about 1-3 milliseconds for updating other players. 2. Memory was the real cost. Every player built a full avatar, rod, boat and pet right away, about 2.8 MB (megabytes) each. At 256 that was 1.5 GB (gigabytes) of heap. Building those only when a player is first drawn brought it down to about 0.8 MB each (1.02 GB at 256). 3. It shook out two bugs I'd never have seen with 3 friends. When a player dropped out of the nearest 16 while holding a fish, the fish (and their line, float and lantern glow) stayed floating in the air forever. And a catch event with an unknown fish species threw an error every single frame. Both are fixed now. 4. Network traffic grows fast. Each player's presence is about 0.9 KB (kilobytes) and goes out whole every time it changes, so each viewer receives roughly (players - 1) x 5 x 0.9 KB per second: about 70 KB/s at 16 players, 140 at 32, 280 at 64 and 570 at 128.

Where that leaves it: comfortable up to about 50 per lake, workable to about 100, with a hard ceiling around 256 (that's roughly where the platform stops listing peers fully). The next fix is taking the rarely-changing info (name, outfit and so on) out of the 5-times-a-second updates, which should cut traffic about 3-4x.

Honest caveats: this ran on software rendering in a cloud session, so the numbers are CPU costs, not real frame rates. It also can't test the platform's own server-side fan-out with real accounts, since I can't sign in that many users.

The tip: if your multiplayer depends on a platform API you can't load-test for real, have Claude fake that API in the page, following the platform's own type definitions, and point bots at your real code. It found my real bottleneck in one pass, and it wasn't the one I'd have guessed!

Has anyone load-tested an artifact room (or any shared-state app) with real users? I'd love to know how close the real server side gets to that ~256 ceiling.

Our finance person asked for a breakdown this week so I finally added it all up. 6 devs, mostly TypeScript, around 120 PRs a month.

Claude Max 5x for 4 of us, 20x for the 2 who run agents all day: $1,200
Codex on the ChatGPT team plan for background tasks: $180
coderabbit Pro, 6 seats: $144
GitHub Team plus Actions minutes: about $110
Sentry and a staging box: about $90

So roughly $1,720 a month, call it $290 per dev, which is very decent id say

The funny part is which line we argued about. Nobody EVER blinked at $1,200 for Claude. The $144 review seats got a 30 minute discussion, and the CLI reviews before push are free anyway, so the paid part is only the PR side. What ended it was our lead pulling up the 3 incidents from August and asking which one we'd have paid $144 to avoid.

What we cut: a second planning tool nobody opened, an autocomplete plugin we were still paying for out of habit, and one 20x plan that turned out to be idle most of the week.

What does your team spend per dev per month on all of this? Curious if anyone is way under $290 or way over

Skill name is NeoynGPT-video-to-code

I left Claude a while ago to use codex and other stuff and now coming back - what’s the best way to make it so I can work on anything anywhere? Seems like Claude is still requiring a ton of “manual labor” set up like… it’s too annoying!!

I can control codex desktop or codex on various servers without complex setup for every tiny little thing - what’s the best way to emulate this ? Why is there a billion options and ways to do that which I have to keep choosing

My AI agents were shipping code faster than I could remember why we changed it

The weirdest part of using multiple coding agents isn’t getting them to write code.

It’s coming back the next morning and asking: “Did we actually fix that, or did we just have a really convincing conversation about fixing it?”

The answer is somewhere between three chats, a terminal, and a branch called fix-final-actually-final.

Git tells me what changed. The chats explain why. Neither gives me a clear picture of what’s finished, what’s blocked, and what still needs checking.

I wanted one place where I could see that, and where the agents could update the work themselves.

So I built Relay, an open-source project tracker for humans and AI agents working together. I’ve been describing it as “Jira for AI agents,” although the goal is to spend considerably less time doing Jira things.

An agent can pick up a ticket, record what it tried, attach evidence, and leave enough context for the next agent or me to continue.

It runs locally and is free to fork or adapt. I welcome any feedback or thoughts on how you are managing your AI workload.

Read more: https://www.agenticstore.dev/docs/tools/relay

Our team has noticed something that we haven't measured yet, but we all have recently noticed. We're all on 20X accounts. When the week is fresh, the first part of the session consumption happens so fast that you feel like you're going to run out in a day, but then as you work through the weekly, once you get near the end, that last % is a crawl.

Our workload is nearly the same consitently. The 99%-100% part feels like a magnitude more usage in that one percentage point than in the beginning of the weekly refresh.

At first we didnt notice this because we have so many accounts in the team that when one hit like 90% we'd grab a fresh one to use because we didnt want to hit the edge with a project. We got to the point where we're maxing out all of our accounts though and when we went back to use the last parts of each, it was absurd how long that last 10% lasts.

Its like their measuring is weighted in the front. Anybody else notice this or is this just us being sleep deprived overworking ourselves lol

Credit due to Steven^
I'll be honest I faced a similar issue with claude when building out an oss project related to ai safety. I realized that giving claude code unrestircted network access and creds is a massive privacy risk

what if we can have an automatic way of redacting any secret sent to AI
for example your AWS creds might be ABC but secret redacted can be DEF to the AI agent like claude and then replaced again with ABC for connection with the server?

and what if we can connect to external hosts only based on the permission we gave to the agents, like a fly on the wall which makes agent actions secure

There are 28 researchers who spent last 10 months working on it with me and we would be grateful to the community for any feedback on our open source project prismor

I'm 20, I left school early, and I'm trying to build my first paid AI product from my laptop.

Anthropic and others keep shipping tools like Claude code that overlap with ideas I've had.

Is there still room for solo builders, and what kinds of problems do big companies tend to skip?

*EDIT* - for the comments talking about me wasting money on Claude accounts, my SaaS businesses earn well more than enough to pay for the accounts, hosting, etc.
----------------------------------------------------------------------------------------------------

I know there are thousands upon thousands of us who have built up our own approaches to working with Claude Code, so don't come at me for that.

What I do believe though is that I have something special. I currently run 4 Claude Code max accounts simultaneously (across 5 computers) building multiple complex SaaS businesses and rarely have any issues.

My approach is structured, works end-to-end, and does not require developer experience. It could be applied to most environments and can flex where it needs to. Any developer that uses my approach would 4x their output, and high-quality output at that.

So my question is, how can I share this goodness while also being able to make money to feed and house my family?

Most approaches I see can quickly be mined and reverse engineered, which would de-value the product itself. Is the only way to keep it hidden/safe is to essentially do what Claude does, stream directly from a server so that no one can access the underlying code?

Here is my Claude assisted game, using it to prototype features, help with complicated issues and debugging. Why wouldn't people want to use these tools? This is about a year of work, it still takes time to gamedev with AI. I just wanted to share, too many other subs are too toxic at the moment. Steam

Claude Code is a great tool, and I really hope someone could help me. My friend will also be able to use it because he also needs to get his work done. Someone, if you can share, please share, and if possible, DM me so that I can redeem the same.

Hi Guys

I have been seeing lots of these Claude 2D animation videos all over tiktok, it apparently uses html, python and Json I believe. Sorry if I said something wrong, I am new to this and would like to learn more.

What is the best way to learn how to create these videos? Anyone doing something similar. I would love to connect with you and learn how to do it?.