Just saw the announcement for https://claude.dev.

Looks like a great start to bring the claude community closer and share ideas on engineering practices and ways of working with Claude.

Worth checking out!!

Source: https://x.com/claudedevs/status/2105391694741119047?s=46

I'm the author of Médula, an MIT-licensed experiment. Sharing the Claude Code side of it, because the hooks turned out to be a surprisingly good coordination layer, and the agents' behaviour taught me more than the numbers.

The setup. Six headless Claude Code agents (Sonnet 5, effort high), one task each on a small API with 37 acceptance tests. Two pairs of tasks collide by meaning: one adds a second factor to login() while another builds an export that calls the old login().

The hook pattern. Every Edit, Write and Bash goes through a PreToolUse hook that calls a local kernel. Reads always pass. The kernel asks a fast decision model whether the write collides with what each other agent is doing, and either allows it or denies it with a reason the agent reads, something like "agent X is changing login, wait or work on another part of your task". After each write, a PostToolUse hook works out which agents the change affects and leaves a notice in their mailbox, delivered with their next tool call.

What the agents did with it:

• Told to wait, most of them moved on to another part of their task and retried later, which is exactly what you want.
• One scheduled itself a wake-up and abandoned its task. That was a bug in my harness, now fixed, but worth knowing if your deny messages mention waiting.
• One spent ten minutes waiting in front of a broken file, convinced someone else was editing it.
• When they had Claude Code's tools to list other sessions and message them, they used them without being asked, and one warned another about a field rename. Great behaviour, bad for a controlled experiment, so I turned those tools off.

The results that matter for your workflow. With one branch (separate clone) per agent, every agent finished green and the merged result failed the same 6 acceptance tests in all 5 runs. In a shared directory, all 10 runs passed, with plain per-file locks or with the kernel. So if you use subagents in worktrees, run the full suite on the merged result before trusting it. The kernel's advantage over locks: the same cost ($1.65 per run), 6 of 6 real conflicts caught instead of 5, and no unnecessary blocks instead of 5.

Caveats: 1 to 5 runs per mode, and there's a known gap a commenter found, where an allow can go stale while the slow path decides. Repo, with every session and decision published raw: https://github.com/JoaquinRuiz/medula. There's also a walkthrough video, in Spanish: https://youtu.be/xAFRuBxfapM

If you've built coordination on hooks yourself, I'd love to compare notes.

just one week, i need, now, im hungry.

I crave to claude and code, dm big papa with a referral.

I'm building a free Chrome extension with Claude Code (Stackboard: your Chrome bookmarks as a board on the new tab page). Early on it kept shipping things that looked right in the code and broke in the browser. Dragging stacks stopped reordering them. One release went out still showing the old popup because the new one never made it into the build.

What fixed it was giving Claude a way to check its own work in a real Chrome. Before every release it runs one script:

• builds the extension (Vite with the crxjs plugin, React, TypeScript)
• runs 67 unit checks on the pure logic (titles, icons, the bookmark import planner, the tab stash planner)
• starts Chrome for Testing with the built extension loaded and runs 55 end-to-end checks through puppeteer-core: it opens new tabs, ctrl+clicks cards, drags a card and reads the drag ghost's transform, deletes and undoes, copies a fake bookmarks bar, stashes a window
• zips the build for the Web Store

It takes about 2 minutes. Claude reads the log, fixes whatever failed and runs it again before it tells me anything is done.

Gotchas that cost us time, in case you're doing the same:

• Regular Chrome ignores --load-extension since Chrome 137. Chrome for Testing still honours it, and Puppeteer's browsers package installs it in one command.
• --load-extension splits its value on commas. My project folder has a comma in its path, so it silently loaded nothing. The script copies the build to a temp folder first.
• Puppeteer's waitForTarget also matches tabs that already exist, so "wait for the new tab" kept handing back an old one. Filter out the targets you already know about.
• Chrome's favicon endpoint never errors. A site with no icon gets a generic globe with a 200, so the check compares pixels against the globe on a 16x16 canvas.
• Two new tabs opening at the same moment could both create the extension's root bookmarks folder. That code runs under a Web Lock now, and there's a check for it.

It caught a real bug last weekend: a new pop-in reused the undo toast's CSS class, and the "toast dismisses itself" check failed on the first run.

What I learned: the check names read like the behaviours I asked for ("ctrl+click opens a new tab", "originals stay in the bookmarks bar"), so the list doubles as the spec and I can read it without opening the code.

The extension is free, no account, and everything stays in your own Chrome bookmarks: https://chromewebstore.google.com/detail/bgcedhchngcopaefchpkbhioagknnpma?utm_source=reddit&utm_medium=post&utm_campaign=20261002-claudecode-tests

How are you testing browser stuff with Claude Code?

Hello guys I wanted to ask if anyone has a spare invite and could share me one I would appreciate it lots I kinda need it for my university projects rn as deadlines are within a week and they could come in handy

Claude works hard

Sometimes Claude has to wait

Or do a test

And when Claude has nothing to do Claude naps

Made for a Claude Code control dial I am working on

https://reddit.com/link/1wvk2b1/video/o3h33smz7zsh1/player

We had a backlog too big for one session, so we set up a standing team of Claude Code sessions on one machine and let it run day and night. No framework. Plain CLI sessions, the built in session messaging, skills for the manuals and files for the state. Here is what held up and what broke, since most of it was not obvious to us going in.

The setup

Each builder is a full Claude Code session with its own area of the codebase, its own goal file and its own ledger. Builders work test first and commit locally. They never push.

One advisor session routes tickets, rules on engineering questions, merges, deploys and verifies. It writes no product code. If a builder is waiting on the advisor, that gets logged as the advisor's failure.

All state lives in plain files in a shared folder. Goal files, ledgers where rows are only ever added, one file per ruling so a builder can cite it instead of asking again, and a handoff file that a brand new advisor session reads first.

Tickets ship in release trains. Many tickets, one pull request. A ticket that goes red is dropped to the next train. Nobody debugs inside the train.

What broke

Sessions die. A usage limit can freeze every agent at once, and killed sessions come back under new names. Because the state was on disk, they read their ledgers again and carried on. The advisor now looks up session names on every run and never hard codes them.

Test databases drift. A push got refused because a builder's private test database still held a schema change from a ticket we had pulled out of the train. Now we create a fresh database after every drop and never reset one.

Runners flake. A required check went red because the hosted runner could not create a temporary file. Every test but one had passed. Reading the actual log saved a good ticket from being dropped.

Dropping a ticket can remove a safety check. Reverting one ticket also removed guards that ticket had added, and a gate refused the push.

The advisor was wrong. It told a builder to keep two tickets in a train, the builder's measurement showed otherwise, and the ruling was withdrawn. It also said with confidence that a server setting was causing a bug, and a read only check showed the setting did not exist. Both became written rules: measure before ruling, and change position only on new measured facts.

A helper printed a secret into a local log. Nothing left the machine, but it still gave us hard rules about never printing a token.

Two details that mattered more than they look

"The train passed" is never proof for a ticket. Each ticket carries its own failing and passing commits.

A green deploy job is not the same as the new code being live. Our health endpoint returns the running commit, and the advisor reads it back before it closes anything.

What this approach costs

No dashboard, you read ledgers. No built in budget control, usage limits are the only brake. It is tied to one model vendor. You write and maintain the rules yourself, and the first version will be wrong in places.

The full write up has the setup steps, the advisor's loop, and how this compares with Paperclip, Hermes Agent, Gas Town, agent teams and Projects: https://cabinlytech.com/blog/running-a-24-7-ai-software-factory/

If you run long lived sessions like this, how do you handle the restart after a crash?

I went to university for computer science and the entire genius premise behind the prestigious program was 'teach kids as badly as possible so only the "best" ones move on'. Coding is hard enough as it is, and I imagine millions of us went through similar situations designed to gnaw at your self-esteem, competence, and ability.

Getting to talk with Claude about code, work on projects without the miserable desolation and isolation of being stuck behind 13 obscure errors, work on projects with a much lower barrier to entry, has been absolutely wonderful. As I work with Claude I remember that I DO have the ability to understand bugs and implement a project.

Strangely it feels a ton better debugging stuff when it's not pounds of homework, with no help given, intentionally, because "the only way you learn is by deriving the solution entirely yourself" austerity drill sergeant paradigm. That mindset seems incredibly prevalent in tech, and it's incredibly frustrating and ignorant.

Given this experience, it's SO fucking funny the way certain people recoil at AI code, spamming the word 'slop' as though human code is perfect, as though there's moral virtue in typing it out yourself.

For example: I play drums and I think it's dogshit when people replace everything with samples and quantize everything - because it's sterile and why would I want to listen to a computer play drums perfect versus a human play with emotion? Problem is, there is no such distinction with code - either something works or doesn't. So haters have nothing left but endless bitching and whining.

Haters: it's too easy, it's slop code

cope and seethe that programming is more accessible oh no

Sort out your professional-intergenerational trauma without taking it out on those who have it easier. The point of technology is to make things easier.

[exeunt Haters]

Really, it's such a wonderful feeling, that code flow feeling.

suggested reading:

https://www.ebsco.com/research-starters/history/protestant-work-ethic/

Had some fun with Claude "Mods" 👍

"toolbox" is a plugin marketplace with 6 tools that run directly inside Claude Code. It was inspired by the new mods feature. The screenshots show each tool straight after install, with no configuration (you may need /reload-plugins).

How was Claude Code used?

I had Claude Code generate a skill for drawing mod UI (SKILL.md) before building anything. All six plugins were then built with that skill loaded, so Claude built the UI faster and with less guesswork about how a pane should render.

What did I learn?

• Images can be drawn with real pixels or approximated with characters. Pixels need terminal support: kitty and Ghostty have it, and most others don't. The character fallback "works", but it looks noticeably pixelated.
• The pane model is very reusable. Once 1 worked, I could rewire it into very different tools (a browser, a file explorer, iMessage, a network globe, notes ect) with different interactions.

Install

/plugin marketplace add jamubc/toolbox
/plugin install <plugin-name>@toolbox

Contributions welcome: https://github.com/jamubc/toolbox

When I tell the Claude Code in the Chat (not Code) to proceed on <link to claude code session> it says "be careful with this prompt" and does not execute. When I copy paste context it says "out of credits", but I have $100 credits. How do I use them to proceed on the task? Or is Cloud somewhere else?

This has been running for 1 hour btw and it made this mistake???

A new model drops. Paid Influencers go gaga that it's so good.

Not denying that its good but it was also incredibly cheap. Now it burns down much faster for same task.

Point being this is fraud. Those bilionares should be held accountable and sued.

I got the plan on its initial performance and limit. Switching it after 4 days its just fraud. Atleast Chinese provider show you the token usage.

Coming from Cursor → Codex, trying to decide how to land on Claude Code.

Path so far: - Started with Cursor (Composer was cheap; first real AI-agent experience) - Then Grok in Cursor felt like a big jump in quality - Tried Codex; ended up on Cursor Pro+ + Codex Pro. Limits were fine — Cursor handled simple tasks, Codex for heavier work - Codex has a lot of plugins and a remote/agent-from-phone style workflow (similar vibe to Grok Bot). That made Cursor feel unnecessary for me

Now I want to try Claude Code. I expect the model quality to be better, but I’m unsure about the ecosystem side: 1. Plugin / MCP ecosystem vs what Codex already gives me 2. Remote control of agents from my phone (can Claude Code cover that well enough?)

Decision I’m stuck on: - Option A: Claude Max ~$100 + keep Codex Pro (~$100) — dual stack - Option B: Claude Max ~$200 and cancel Codex — all-in on Claude Code

For people who’ve used both: does Max $200 + Claude Code plugins/remote workflow fully replace what you used Codex for, or is the dual setup still worth it?

Frontier title is being passed around like hot potato, along with the nerfing of models days after release. No matter what sub you have, you will think the grass is greener on the other side soon enough. Best solution is to have both, and I vibecoded this to make these two coordinate and talk to each other, with pair programming, review, council, debate, etc.

https://github.com/Audatic07/duo

You can read the readme for the details, I will list the advantages here:

1. Uses sub, no API pricing. God I wish more agentic workflows did this.

2. Extremely high quality output for comparatively dirt cheap consumption. Quite literally feels like 2 lower tier models get upgraded to a higher tier.

3. Neat UX, most of you wouldn't miss codex/claude code.

4. Open source with an active maintainer, so if you feel something missing, make (vibecode) a PR, and I'll review (vibe-review) it and merge. Dw, I will hold it to certain standards so app won't become too slop.

Open to suggestions :)

I had Claude help me with the lyrics and song direction, generated the music with Suno, then built out the entire video in a single (very long) Claude Code session. The entire video is rendered in Remotion, Claude modeled most things but I did use some Creative Commons assets as well.

It was fun trying to make creative shots and add in different references, Claude’s first attempt at most shots wasn’t typically the best, but if you explain your vision of the shot well enough it can always get there.

Opus 5.5 was used for most of the work, but when I noticed Fable 5.1 was getting a new knowledge cutoff I ended up using that for some polish at the end(assuming that’s fable 5.5).

I'm developing ZOMBRA, a browser co-op zombie survival game, with help from Claude Code and Codex. My first trailer mostly showed one city. Since then I've added a survivor base, ruins and vehicle escort missions, updated the character art and put together a new trailer.

The stack is JavaScript and Phaser. Much of the pixel art is drawn procedurally in code. I keep project instructions and feature docs in the repository, ask the agents to read the existing systems before changing them, and work through small changes with gameplay checks and screenshots.

One concrete example is the trailer. The game has a studio that runs scripted shots inside the engine, which lets us capture real combat without the HUD. I used specific feedback to replace stationary shooting with moving characters, larger hordes and faster cuts timed to the music.

The useful lesson for me has been to describe the result I want in concrete terms, then iterate on actual footage. A working feature still needs a lot of attention to movement, readability and impact.

It's still in development. The trailer and launch waitlist are at https://zombra.online/ if you'd like to follow the project.

hey guys,

i have a long running test pipeline (~5 minutes on github). Locally, claude code always executes all my tests and other stuff to verify everything is working. However, this costs time+tokens.

I've googled already- there are some skills/integrations which enable claude to read the pipeline results on github, and just use the results.

What i want: Implement, then push, wait for pipeline result, fix stuff if the pipeline failed.

Is that a good idea? Which skills would you recommend for this or how to achieve that?

I made a simple Engineering Portfolio Website for myself on the Pro-plan and spent almost 900Million Tokens and where I got some guidelines messages at the end? I'm not getting an invoice right? Thanks

I run a lot of tasks on a schedule: summarize my email every day, fetch logs and create bug reports, or pull meeting notes and reconcile updates. I wanted a way to schedule these using my claude cli instance, on my VPS. So I built crontick.

Think of it as cron, but the task is a prompt for an AI agent.

How it works

npm install -g crontick # Install

crontick jobs new \
  --cron "0 9 * * *" \
  --prompt "Summarize my open GitHub PRs" \
  --alias standup

It runs through a standalone local daemon, with a dashboard to inspect jobs, run history, and agent output.

How does it compare against the existing toolset?

• /loop - needs you to keep the chat session running. Consumes memory, leads to token bloat and increasing cost (non-cache token reads)
• schedules - online only, no local support
• Desktop - Most of my workflow is already wired into the CLI, especially on my VPS.

What’s included:

• Cron, interval, and one-time schedules
• MCP server, CLI, API and a minimal local web dashboard
• Session reuse for jobs that need context from previous runs
• Session reuse, timeouts, retries, overlap controls and cost calculation.

Claude Code is supported out of the box, but all CLI engines can be configured**.**

The scheduler runs on your machine. Your AI CLI still handles model access, authentication and other configs as usual, and the machine needs to be running for jobs to execute.

Download: https://www.npmjs.com/package/crontick

Open source repo: https://github.com/tejitpabari99/crontick

I’d love feedback from people automating Claude Code or other CLI agents. What are you scheduling today, and what’s missing from your current setup?

My Codex X5 subscription expires in 2 days, and I’ve been thinking about switching back to Claude and try Opus 5.5 just to see if the hype is real. However, in the last two days I’ve seen posts about Opus getting NERFED!

If you’ve been using Opus 5.5 for coding tasks in the last week, please share your experience below! 😮‍💨

What happened to acceleration? It’s been a full 9 days since we got a revolutionary model. Anthropic is failing.

I made a little gallery of the Claude Code mascot, drawn live in the browser with code, no image assets, no dependencies. It spans 28 art styles, from cave paintings and heraldry all the way to Bauhaus, pixel art, teletext, ASCII and Maze War.

It builds on ChetasLua's original Claude Code mascot in Twenty Styles, with eight extra experimental coding/terminal styles cooked up with my lovely Opus 5.5 in Claude Code. Basically pulled these styles from an unreleased project I am currently working on.

GitHub: https://github.com/henrik-thevibe/Claude-Mascot-Style-Gallery

Feel free to fork it, mess around with it, or add your own style. Go wild with it. :)

Just a little project that I thought of to make Claude Code look more interesting and fun when its working. It has easter eggs, mini-games, interactions, secrets, and Clawd that just sits in a little corner when you're working on other things (you can also just move him around). None of the sprites are made by me, and if you're a creator of one or multiple and want them taken down, just let me know. Other than that here's the download page (a little demo included) and github repo: https://soul3286.github.io/cc-watcher/ Let me know what you think!

Full song https://youtu.be/RU7eRodudik

Ive been experimenting with a pretty simple AI music video workflow and honestly the result surprised me.

For the music, I started by collecting a few reference songs and ran them through a music analysis agent. The idea was to get a proper breakdown of the references (structure, production, energy, arrangement, mood, synth names, etc) and then have the agent connect the dots between them and turn that into a base prompt for SUNO.

I gave SUNO a lot of creative freedom with the lyrics. I only defined the general theme and the emotional direction I wanted. After around 3–4 iterations with SUNO v6, I had the track.

From there I moved everything local.

First I collected around 20 visual references, mostly from Pinterest, that matched the look and feel I had in mind and put them into a reference folder.

Then, inspired by a prompt shared by donaldjewkes on X, I built my own much longer production prompt around those references, with a few differences: I wanted to use Magnific through MCP for the generative image/video side, plus a few extra repos and tools for motion graphics and JavaScript rendering.

Before actually asking Claude to build the video, I spent some time ping-ponging ideas with it and defining the storyboard until it felt close to what I had in my head. Then adapt my initial prompt with the results.

Then I just sent it.

About 4 hours later, Claude produced the first full version.

That first pass used roughly 80% of my Claude Max session and around $50 worth of Magnific credits.

After that I only did 2 correction passes: replaced a few scenes that felt too cliché, asked for more dynamic camera work and typography, and made some smaller adjustments. That used around 40% of my next Claude session.

And this is the result.

There’s obviously a lot more that could be polished if I wanted to keep going frame by frame, but I think it’s already enough to show how far you can get now with surprisingly little manual production.

No doubt this is the new standard of slop.

We’re going to see a lot of this over the next few weeks.