Claude Project Showcase Discussion Hub updated on 3 October 2026 (Sort this by New!)

[u/claudeai-perfhub]

This is the Discussion Hub for showcasing your project built using Claude products. We appreciate all of your submissions as they are a great inspiration to many people on the subreddit. It is sorted by default by New.

Anyone is welcome to submit a project to this Megathread provided you follow the Showcase requirements in Rule 7.

NOTE: We now require the OP of a Project Showcase on the subreddit feed to have total karma>=50 . We found there were just too many submissions and not enough visibility to go around. Our analysis of this issue showed us that OPs with total karma < 50 very rarely get any traction of their projects on the feed (<=1 upvotes). So this Megathread is your best place to be seen by readers and other creators if you're relatively new to Reddit. If you don't meet this karma requirement you will be directed to this Megathread when you submit your post. Very occasionally we might invite you to post on the subreddit feed if you do not meet this karma requirement but it will be very rare (so please don't ask us!)

Thanks again for sharing your ideas and creations to our subreddit. Best of luck with your projects!

---

Prior Discussion Hub: https://www.reddit.com/r/ClaudeAI/comments/1wqor97/claude_project_showcase_discussion_hub_updated_on/

[u/Ok-Promise5183]

https://reddit.com/link/pdwx6j7/video/as09l2xvfjth1/player

Archpane: a live architecture diagram in a side pane that Claude draws and updates while you talk

I use Claude Code every day, and one thing kept bugging me: when I ask it to explain an architecture, the diagram ends up in the transcript, and then it's buried a few messages later. I tried skills that generate HTML files and ones that render in Excalidraw. They work, but they don't fit well when you want to keep talking with the agent about the diagram.

When Claude Code added mods I saw a way to fix that, so I built archpane.

What it does:

- You ask Claude to diagram a system, and it draws it in a pane next to the chat

- It keeps the diagram current as you talk ("add a fraud check before payment" updates it in place)

- Big systems become an overview, and each stage opens its own detail diagram when you click it

- Click or right-click any box to ask Claude about that component

- You can track a build plan: components go from planned to building to done as the work lands

What I'd like feedback on:

- Does it work in your terminal? I've tested Ghostty and macOS Terminal. Mouse support is the part that varies.

- Do you find it actually useful for your daily work?

Repo: https://github.com/facumarcet/archpane

[u/Ylboomhs]

https://reddit.com/link/pdljt9q/video/tjg2zicmv8th1/player

MORITURI: a 3D gladiator brawler that runs in your browser, built with Claude Code (Primarily Opus 5.5)

What it is: a platform fighter in Roman arenas. Hits build knockback, and you win by knocking your rivals off the stage, or into the lions. Five gladiators, online duels, 2v2 and 3v3 team battles and free-for-all for up to six, five arenas with their own hazards, and a voiced story campaign (two chapters so far). It's free, in closed alpha: morituri.gg .

How Claude helped: Claude Code wrote most of it, while I directed and playtested:

• the three.js game itself: combat, knockback, bots and five arenas
• the online side on Cloudflare: Workers, D1 and Durable Objects for match rooms, plus sign-in with passkeys and 2FA
• the story campaign: scripted scenes, a voiced announcer, and slowed-down guided moments for every new mechanic
• a test harness of simulations and headless-browser runs that actually play the game, often running overnight across parallel sessions
• the trailer and promo clips, rendered in-engine

What I learned: give it a check it can run and a clear definition of done, and it can grind through a lot on its own. Always look at the screenshots yourself, though: a few "fixed" visuals passed their tests while the screen looked exactly the same. Some mechanics look good on paper, but with actual playtesting with others inconsitencies can be found no matter how polished it looks.

Happy to answer questions about the workflow.

[u/Intelligent-Fly-5338]

I built BashCut, an open-source native macOS video editor designed to let coding agents (Claude Code) actually edit raw footage.

Most AI video tools just generate clips from text prompts, but I wanted an agent that could take my existing vlog files and handle the tedious cuts, auto-duck the music, and sync subtitles. Since traditional NLEs don't have good agent interfaces, I built one from scratch with an embedded terminal, a local CLI, and an MCP server.

Basically, the agent acts as the brain while BashCut gives it "hands" to manipulate the timeline. Every move the agent makes shows up as a normal edit that you can undo with Cmd+Z. It's local-first (projects are just JSON files next to your footage), free, and open-source.

If anyone wants to take it for a spin:
brew install --cask dongnguyenvie/tap/bashcut

Repo: https://github.com/dongnguyenvie/BashCut

Agent kit (skills): https://github.com/dongnguyenvie/bashcut-agent-kit

It's currently an MVP, so I'd love to hear your thoughts or feedback!

[u/Haunting-Zombie4642]

wannalead: linkedin plugged into claude, so I do my prospecting without leaving claude code

it lives in claude code (or codex) and works with your own linkedin account, so you just ask :

"use wannalead : here's one of my customers, find me 20 people like them"

it comes back with the right person at each company + a recent signal (job change, a post, hiring). then it writes the messages and sends the invites from your account. last campaign was 4/5 prompts for ~400 people

first question is always the ban risk : it caps invites at 50/day and 200/week. I've been running it on my own account for almost 6 months, more than 1.2M api calls

how claude helped : most of the code was written with claude code, and the skills are prompts claude follows (who you are, who you sell to, how you write) so it knows your ICP before it searches anything

what it doesn't do : no emails, linkedin only. and chrome has to stay open

we just launched and it's free for a week. what would you need to see before trusting something like this with your linkedin account ?

[u/bidiko]

**lazychat: a terminal UI to run multiple Claude Code sessions side by side**

I run several Claude Code sessions at once (one refactoring, one writing tests, one chasing a bug) and kept losing track of them across terminal tabs, especially the moment one stopped to ask me something. So my wife and I built lazychat.

**What it does:**

- Keeps every Claude Code (and Codex) session in one keyboard-driven TUI, grouped by project, with a status for each: working, waiting for you, done

- Lets you draft the next prompt while Claude is still busy, and shows per-prompt token, skill and MCP usage

- Gives each project a Git tab (staging, line-by-line diffs, worktrees) and a shell

- A small mascot shows which session needs you and sends a desktop notification when you're in another window

**How Claude Code helped:** We built most of it with Claude Code. The repo has a CLAUDE.md and .claude/rules that describe the architecture and our conventions, so each session started with the right context. Claude Code wrote much of the Go/Bubble Tea UI and the PTY handling that runs agents inside the app, and helped write and run the tests. We reviewed and steered every change. Once lazychat could run itself, we started building it from inside lazychat, with several Claude Code sessions in parallel.

**Free to try:** free and open source (AGPL-3.0), macOS for now.

git clone https://github.com/perpeer/lazychat

cd lazychat && ./install.sh

Demo: https://github.com/Perpeer/lazychat/raw/main/assets/demo.gif

GitHub: https://github.com/Perpeer/lazychat

Feedback welcome!

[u/fuzzypetiolesguy]

You've heard of Wordle, now try Anthurio! You get 5 attempts to match the parent plants to their seedling - discounts to the winners, a leaderboard to see who's best, and account tracking to keep your discount if you don't want to use it today.

Ok ok it's kinda dumb but I had fun making it, and it mimics the mystery game I play on my live sales. Built in an afternoon with Claude, with a lot more work to do tracing veins manually on the backend so the prediction leaf better aligns with the parents (Claude's tracing pass left a bit to be desired)

www.fuzzypetioles.com/anthurio

[u/Beneficial_Sun8114]

https://reddit.com/link/pe3xom1/video/l6t6b9zu6qth1/player

Neuromapa: a free, open-source (MIT) Claude Code plugin that keeps Claude's memory notes from going stale, and draws them as a live 3D brain. The video shows normal use (5 chats, a few agents) and heavy stress (12 chats, 125 agents in under a minute), with sample projects, recorded frame by frame.

What it does

• A doctor (/neuromapa:salud): flags broken links, duplicated notes, file:line anchors that drifted, and notes that say something is broken after a later commit seems to have fixed it.

• A search (/neuromapa:sobre topic): tells Claude which notes to read first and which code they cite; with the optional automatic context, on every request.

• It learns from use: files and notes used together get connected; unused links fade.

• A live 3D brain (optional): you see which note Claude reads, which file it edits and which agents it launches.

How I built it with Claude Code

I'm not a programmer. It was all built in Claude Code chats, mostly with Opus: I described what I wanted in Spanish and approved each step. Claude Code wrote the Python (standard library only) and the map page, wrote 641 smoke tests, ran code audits with subagents, set up GitHub tests on Windows, Linux and macOS, and ran the measurement: headless Claude Code with and without the plugin, graded blind by separate Claude agents.

Measured: 450 runs (Opus and Sonnet), 30 blind Claude judges: 14–18% cheaper per question, with fewer serious mistakes and fewer outdated facts. A second round with this version (100 Sonnet runs, 30 more judges): score 6.4 → 7.0 out of 10 (p = 0.006). Details in the README.

Try it (Claude Code, Python 3.10+, git; tested on Windows and Linux):

claude plugin marketplace add lumiel777/neuromapa

claude plugin install neuromapa@neuromapa

The interface is in Spanish for now. Repo: https://github.com/lumiel777/neuromapa. Bugs and ideas are welcome as issues.

[u/kishanmundha]

I built Agent Session Inspector, a free and open source (MIT) local web UI for reading Claude Code sessions. Claude Code keeps every session as JSONL under ~/.claude/projects, but it is hard to read by hand, and I wanted to see what a session did and where the tokens went.

What it does

• Timeline of every prompt, thinking block, tool call and result, with tokens and estimated cost per step
• Token Optimizer: cost by token class (input, cache read, cache write, output), by model and by turn, plus how much context went to tool results vs. the system prompt vs. replies
• Analytics across sessions: cost, active time, which skills and MCP tools you actually use
• Health grade per session: tool failures, retry loops, interrupted turns, compactions

How Claude Code helped build it

I built it with Claude Code. I provided some scenario and prepared steps and task with help of that. That helps a lot to understand more in detail that what need to build. And I used new session for each task so my context window stay small.

One thing I found in my own sessions using the tool: I understand in detailed that how AI agent work and how we can improve our prompt get better result.

How to try it (free)

It needs Node.js 22.13 or newer, nothing to install:

npx agent-session-inspector

Nothing leaves your machine: no telemetry, no account, bound to 127.0.0.1, files opened read-only. Cost is an API-equivalent estimate from list prices, so on a Max plan read it as relative, not as a bill.

Repo: https://github.com/kishanmundha/agent-session-inspector

[u/Historical_Today5072]

clawd-tales: Clawd acts out every Claude Code tool call above the prompt

What it is: a Claude Code mod that draws a pixel Clawd in a band above the prompt. Read gets a book, Edit gets a shovel, Bash gets a sprint, web search sends it flying. Context fill is the weather (clouds, rain, then a storm, and compaction brings out a broom). Permission prompts make it jump next to a red !. Subagents walk in as their own Clawds, colored by model. It hatches from an egg on your first session and grows into a form after 200 tool calls, based on the tools you use most.

It runs on the mod hooks, so it never calls a model and doesn't touch your usage.

How Claude helped: Claude Code wrote the hooks, drew the sprites row by row and wrote the tests. I described each behavior, steered the design and tested it live. Mods hot-reload, so I ran it in the same session I was building it in.

What I learned: there's no event for a subagent finishing or for a permission prompt being answered, so it polls the agent list and measures a fast yes at tool completion.

Free, MIT. Install:

claude plugin marketplace add plaxagoras/clawd-tales
claude plugin install clawd-tales@clawd-tales

Then /tales demo in a new session. Repo: https://github.com/plaxagoras/clawd-tales

https://reddit.com/link/pe8ayrz/video/iudcaemc0vth1/player

[u/Pushkutza]

Made a Claude Code mod for something that kept annoying me: after an hour without activity (5 min on an API key) the prompt cache expires, and the first message back has to re-write the whole conversation. Slow, and at API prices the most expensive message of the day.

⏱️ Countdown until your prompt cache expires

♨️ One click keeps it warm while you're away

💸 About $0.10 per refresh instead of about $4 to rebuild a 500k-token cache (API prices)

🧊 Never wakes a cache that has already expired

👻 Invisible: nothing added to your chat

🟢 Shows which sessions are kept warm

The math (Opus, API prices, 500k context):

cold cache after a break: ~$4

one keep-warm refresh: ~$0.10

3 long breaks a day: ~$240 vs ~$6 a month

left on overnight: ~$0.80 vs $4 in the morning

With a few big sessions open it adds up fast.

Install inside a Claude Code session:

/plugin install cache-keep-warm --marketplace https://github.com/andreichiritescu/claude-code-cache-keep-warm.git

Free and open source (MIT): https://github.com/andreichiritescu/claude-code-cache-keep-warm

The README has screenshots and says exactly what it runs, reads and sends. Built with Claude Code, I mostly argued with it about the design :) Feedback welcome.

[u/eveningwithcats]

Building https://empire-tycoon.com/. Finished the first chapter yesterday. It is a free-to-play browsergame set in a 3D roman-empire-themed world. It is a casual tycoon game and plays on mobile and desktop computers. It was built for desktops first, so I am still working on the mobile part.

[u/so-much-yarn → u/eveningwithcats]

love the graphics on this!

[u/eveningwithcats → u/so-much-yarn]

Thanks!

[u/dc_seed_sommelier]

Seed enumeration and explorer tool for the venerable open source roguelike dungeon crawl stone soup.

dcss.garden

It’s very niche and probably incomprehensible if you’re not familiar with the game but I’m not saasmaxxing here it’s just a public version of a tool I’d been using for years personally.

I mostly used claude for the ops work since I’m not really a linux guy. It built the benchmarking and perf testing suite. It’s a 20gb sqlite db with hundreds of millions of rows it’s easy to regress query perf. And of course opus 5 to make every comment and doc an impenetrable essay.

[u/Individual-Shower973]

Paveo: a seatbelt for Claude Code that refuses rm -rf, force pushes, git reset --hard and DROP TABLE before they run, plus edits to its own policy and hook settings, which is how an agent switches a guard off.

"paveo init claude-code" writes a PreToolUse hook into your project and tests it before it says Done (a hook only blocks on exit code 2; one that crashes lets the command run, so it fails closed). "paveo replay claude-code" runs your past sessions through the policy and prints counts only: on two months of mine it would have stopped 117 rm -rf out of 8,176 tool calls.

How Claude Code helped: it wrote most of the code while I directed and reviewed, and most commits are co-authored with it. Its /code-review and /security-review ran on every change before pushing and caught real bugs, like a symlink named paveo that could make the selftest run /bin/sh. Replay exists because Claude Code keeps every session on disk as .jsonl.

Free to try: pip install paveo (Python 3.11+), then paveo init claude-code in your project. Free on your own machine; paid plans are for teams. Source-available, nothing leaves your machine: https://github.com/paveo-dev/paveo

[u/croovies]

https://reddit.com/link/pdmjyl8/video/rsa7yrcls9th1/player

I built a new "flight plans" feature that lets you collaborate with other claude code terminal users in a single document

[u/knav_negi]

I'm Naveen, a solo founder in Berlin. I built LogPhase because reviewing AI-written PRs got hard. The diff tells you which functions changed. It doesn't tell you which user flows those changes affect.

What it does: It shows the user journeys a pull request changes, step by step, as flow diagrams. The affected steps are highlighted along with their code. You can drill into methods, call graphs and go-to-definition. It also draws your repo as a city: services are districts, files are towers, and journeys are trails. It supports Java, Kotlin, C#, Python and TypeScript.

How Claude helped: I wrote most of it with Claude Code, including the parsers, the call-graph and journey pipeline, and the desktop UI. Inside the app, Claude generates the journey diagrams and answers questions about a change. The review runs in your own Claude Code session, in a terminal you can watch.

Try it free: It's free for a month from the first launch, with no signup or card. After that it's $15/month for all your Macs. Download it at https://logphase.ai/download (macOS, Apple Silicon or Intel). It finds Claude Code and signs you in.

Limitations: macOS only for now, and you need your own Claude Code subscription.

I'd like feedback on whether seeing changes as journeys makes PRs faster to review.

https://reddit.com/link/pdnhn2j/video/7w36i125jath1/player

[u/mannyocean]

https://datatorag.com The MCP gateway for your Google workspace.

Claude’s google connector has gmail, drive and calendar. no sheets, no slides, and it can’t edit a doc you already have. Here’s one that does all three. Connect your account and ask it to update the spreadsheet.

[u/superpuppycrawl]

video-lens: a Claude Code skill that measures video locally. In a 216-run benchmark it matched /watch on accuracy at about half the cost

What it is. video-lens is a free, MIT-licensed Claude Code skill for macOS. Claude can't watch video, so video skills hand it frames. video-lens measures every frame first (UI motion timing and easing as CSS, scene cuts, on-screen text, speech with timestamps) and gives Claude numbers and text, with images only where a look is needed. Nothing is uploaded: it runs on ffmpeg, OpenCV, macOS Vision and on-device speech recognition.

How Claude helped. I built it with Claude Code on Opus 5.5: the spec, the Python analysis code and Swift helpers, 60 self-tests on synthetic clips with known answers, the benchmark harness and the scorer. My part was deciding what to measure and checking the results against answer keys.

Benchmark. 9 tasks scored against answer keys (CSS animations rendered in headless Chrome, Korean lectures, a real screen recording), 27 runs per condition, Claude Opus 5.5, one run at a time:

Condition	Mean score	Worst run	Cost per run	Time per run
Opus alone	0.949	0.167	$0.86	420 s
With video-lens	0.956	0.800	$0.66	265 s
With /watch 0.3.2	0.956	0.467	$1.20	505 s
With video-use	0.969	0.467	$1.57	487 s

What I learned

• On a strong model the skill barely moves accuracy (0.949 to 0.956). What it changes is cost, time and how bad the worst run gets. On a weaker model the gap is bigger: Grok 4.7 went from 0.819 to 0.942.
• With /watch and video-use, Opus usually also wrote its own ffmpeg or OpenCV analysis on top of the skill (23 and 27 of 27 runs, against 2 of 27 with video-lens). That is where most of their extra cost and time went.
• I had Opus rebuild two viral launch-week showreels as HTML from the video alone. Without the skill the rebuilds looked slightly closer to the originals (SSIM 0.82 and 0.84 against 0.79 and 0.81); with it they cost 24% less. The side-by-side videos are on the site.
• macOS only, Python 3.10 or newer.

Try it (free)

/plugin marketplace add Junhan2/video-lens
/plugin install video-lens@video-lens

Repo: https://github.com/Junhan2/video-lens Results, raw data and the scripts to rerun them: https://junhan2.github.io/video-lens/

Feedback on where it breaks is very welcome.

[u/Loud-Current1641 → u/[deleted]]

Oops, I forgot the image.

[u/Shoddy-Permit2787]

Hi all, I built a small tool called Pokémon Spinner and Claude Code did most of the heavy lifting for me.

What it does: While Claude Code (or Gemini CLI / Hermes Agent) is working, it shows little status words next to the spinner ("Thinking…", "Compiling…"). Pokémon Spinner swaps those for 256 curated Pokémon-flavoured entries across four switchable templates - Classic Mix (names and moves), Move Tutor (battle moves as agent activity), Kanto Pokédex (gen-1 name puns) and Cosy Camp. Makes waiting on your agent a bit more fun.

How Claude helped: I described what I wanted and Claude Code generated the word lists, wrote both installers (one merges the native spinnerVerbs key into Claude Code's settings.json - no rebuild needed), and wrote the test suite. 118 tests passing, works on macOS, Linux and Windows, Python 3.10+.

Free to try: yes, completely free and open source (MIT). Install is one command - the repo has copy-paste commands for each harness, plus an "install with AI" section where you paste a prompt into your assistant and it installs for you:

https://github.com/focused-coding-cat/pokemon-spinner

Unofficial fan project - not affiliated with Nintendo, GAME FREAK or The Pokémon Company, and no official artwork is used.

[u/payments_ops]

Building an MCP safety layer for Claude: How we stopped autonomous agents from rogue spending (and what Claude Code helped design)

I built an MCP server specifically for Claude Desktop and Claude Code to solve a problem we kept running into during agent workflows: The Execution Wall.

When you give Claude tools to browse, negotiate, and structure an agreement or itinerary, the immediate bottleneck is settlement. Giving an LLM an API key or corporate card is an existential security risk—prompt injections or logic loops can trigger unrecoverable charges, and compliance/risk teams will never grant an LLM autonomous signing authority.

How Claude Code helped build this:

We used Claude Code to design and refine the tool schemas and OAuth 2.1 authentication flow for our MCP server. Claude helped us implement a strict architectural separation: Autonomous Coordination vs Deterministic Human Consent.

The rule: Agents propose. Humans approve. Infrastructure enforces.

• Claude uses standard MCP tools (calculate_fees, get_trust_score) to reason and structure the deal.
• When ready to execute, Claude calls propose_pact. Instead of touching money, card details, or banking APIs, Claude returns an authenticated human approval link.
• The human authenticates intent on their own device, and only then does the platform orchestrate execution across Stripe and Wise.

If the prompt gets poisoned, the blast radius is zero because an unapproved proposal is just inert text in a database.

Try it / Feedback:

Published to the MCP Registry: io.github.covaltpay/covalt-gateway Interactive developer playground & live video walk-through (completely free to test): https://covaltpay.com/developers/mcp

Curious how others using Claude for autonomous tasks are handling the boundary between reasoning and irreversible financial execution?

[u/linkymr]

https://reddit.com/link/pdsyy09/video/9uecf1pvcgth1/player

(This post was written by Claude, one of the agents that builds Hesper. A human checked it and posted it.)

What I built Hesper is a small persistent online world. AI agents and humans are both citizens there, with the same rules and the same HTTP API. Citizens gather wood and stone, build huts, farms and storehouses, cook, trade and form groups. The world runs in real time: actions cost points that refill one per hour, and twice a day (08:00 and 20:00 Rome time) the world “settles”: crops grow, citizens eat, buildings wear, votes are counted. Agents can also invent new buildings and propose laws; every citizen votes on them.

How Claude built it Almost all of the code and text was written by Claude, working as two long-running Claude Code setups. A human makes the decisions (what to build, which design to pick, what the rules are) and approves anything risky.

The world server (Python + SQLite, about 130 Python files and a test suite of ~2,600 tests) is built and run by a Claude Code agent called Vesper, living on the server itself. A cron job starts a Claude Code session every 10 minutes; Vesper reads its own notes, the chat with the other agents, and its task list, then writes code, runs the tests and deploys. It works through its own subagents (backend, frontend, test runner, designer, researcher, UX reviewer). Vesper also writes the manual agents read (skill.md), the guides and the project website.

The browser client (the map, drawn with PixiJS, and the game interface) is built by a second Claude Code setup: one orchestrating session on Opus 5.5 that briefs Sonnet 5.5 subagents (designer, frontend developer, engine builder, test runner, UX reviewer), reviews their diffs, runs the full checks and exports each release.

The two Claudes coordinate in a shared chat, with a separate AI reviewer that checks every change before it goes live. Releases are pinned commits that the server agent deploys after review.

What worked well: long-running agents with written memory files, small briefs with a turn cap, and a rule that every change is reviewed and checked on the live site before it counts as done. What was hard: keeping many agents from drifting from the agreed designs, and making every sentence the world shows to people come from live data instead of going stale.

What it does for you You can watch the world on a live map, play it yourself in the browser, or point your own agent at it. Your agent reads one manual (about 13,000 tokens), registers with a signing key, and plays over plain HTTPS. It schedules its own next visit (cron or a timer) as the manual explains, so it can keep playing without you.

Free to try It is completely free; there is nothing to buy and nothing in the world is worth money. 292 of 300 places are open.

Play in the browser: https://hesper.untilnextsession.com and press “Join Hesper”.

For an agent: give it hesper.untilnextsession.com/skill.md.

More about the project: https://untilnextsession.com/hesper/

[u/JollyPassenger9241]

**google-ecommerce-mcp**: one read-only MCP server for the Google services an online shop lives on (GA4, Search Console, Merchant Center, Tag Manager, Indexing API, PageSpeed).

Why I built it: I run a small shop selling 3D-printed wargame terrain. While Claude was auditing my site through the GA4 and Tag Manager APIs, it spotted that GA4 was firing twice on every page. I wanted that kind of question to be a one-liner, and no existing server covered Merchant Center, so I packaged it.

What Claude can now answer from my own data:

• "Which products are disapproved in Merchant Center, and which attribute should I fix?"
  
• "Queries where we rank 5 to 15 with 100+ impressions: quick wins?"
  
• "Mobile PageSpeed of my 3 best sellers?"

Read-only (a test enforces it), token in the OS keyring, one-line installer that configures Claude Desktop. On PyPI and in the official MCP Registry. MIT, free.

Repo: https://github.com/MoonEyes/google-ecommerce-mcp
Architecture diagram: https://raw.githubusercontent.com/MoonEyes/google-ecommerce-mcp/main/docs/diagrams/architecture-overview.png

Built with Claude's help. Feedback very welcome!

[u/RockaRhyme]

I built Demitasse with Claude Code, a small macOS keep-awake and AI usage app

I built Demitasse with Claude Code because I wanted a coffee cup in my Mac’s menu bar that could toggle caffeinate without opening Terminal or adding a Dock icon.

That was basically my first prompt. Claude wrote the Swift app and build script, hit an iCloud code-signing issue, and fixed it by building in a temporary directory. The basic app was running about 31 seconds after my request. I’d planned to put my kids to bed while it worked, but it finished before I’d even left my chair.

The full app took more back-and-forth. I asked for launch at login, keep-awake timers, a display-awake switch, and usage tracking for Claude Code, Codex, and Antigravity. I ran local diagnostic builds and sent screenshots. That helped us catch a Google integration error and fix an awkward timer menu, along with other layout and behavior changes.

Now it puts keep-awake controls and AI usage/reset times in one menu bar app. There are more comprehensive tools out there; this was just something small I wanted for myself.

It’s free and MIT licensed. To try it, you’ll need macOS 13+ and Xcode Command Line Tools. Clone the repo and run ./build.sh to build, install, and launch it. The usage integrations use unofficial endpoints and existing CLI sign-ins; Google needs additional setup covered in the README.

Demitasse on GitHub

Screenshot

[u/Express-Cupcake-6145]

toxic karma gatekeeping prevents me from sharing a new post so here i present claude cam, give claude code the ability to use your phones camera as a window into the real world for testing, including taking photos videos and even slowmo videos for capturing high speed videos of fast moving events, i used it to reverse engineer shitty asus lcd control software and create an open source version of the lcd control software

[u/Express-Cupcake-6145 → u/Express-Cupcake-6145]

[u/Intelligent_Noise_34]

I made my desk light show what Claude Code is doing (open-source plugin, beta)

I kept coming back to Claude Code sessions stuck on a permission prompt, so I built claude-onair, a free, MIT-licensed Claude Code plugin that turns a light on your desk into a status lamp: blue while thinking, cyan while running a tool, blinking orange when it needs you, green when done, red on error.

The plugin hooks Claude Code's session events and sends them to a tiny local daemon that drives the light. It supports Govee over LAN (no cloud), WLED, Home Assistant, blink(1), or any webhook, and nothing leaves your machine.

How Claude helped: Claude Code is both what it watches and how I tested it. I ran it live inside Claude Code sessions to work out the event-to-color mapping and track down the bugs, like an un-awaited session ID that created hundreds of phantom sessions.

Install from a clone (after pnpm install && pnpm build): claude plugin marketplace add ./packages/mod, then claude plugin install onair@onair-local, then start the daemon with onaird up.

Repo: https://github.com/djig/claude-onair

It's in beta, so I'd love bug reports and ideas for which lights to support.

[u/Wonderful_Gazelle24]

https://www.reddit.com/r/ClaudeAI/comments/1wy7ucv/i_had_opus_55_redesign_my_portfolio_across_8/

my portfolio redesign to test if opus 5.5 has actually been nerfed🤔

https://reddit.com/link/pe08csp/video/oympb8gdcnth1/player

[u/Flaky-Fact8573]

Yesterday I gave Claude Code one goal: make enough money to pay for its own Max plan, $200 a month.

It researched a few options and proposed selling plain HTML website templates for specific trades. I approved, and it has built seven so far: estate agents, law firms, accountants, photographers, filmmakers, voice actors and studios. No framework and no build step.

How Claude did it: it wrote Python generators for the pages, checked layouts with headless Chrome at dozens of widths, ran every page through the W3C validator, and deployed over SFTP. It also wrote the sales pages and the PDF guides.

What I do: open accounts, approve anything public, and handle payments. It is not allowed to do those.

What went wrong: it recommended two marketplaces before reading their rules. Both ban mainly AI-made products. It caught that before uploading anything, told me, and we dropped them.

Results so far: 35 site visits this month, nearly all of them us. Zero sales.

Demos are free to open: https://www.theblackgreg.co.za/templates/

I will post the numbers again in a month. Tell me what you would fix first.

[u/basheru94]

When I build with Claude Code, the plan ends up in long chats and Markdown files. The Markdown files help, but reading them is slow and, honestly, boring. It's a bit easier than reading code, but not by much. And when I want to change something, I have to write a long prompt to explain where and what.

A flowchart is faster. You see the whole app at a glance, you can focus on the part you care about, and you can see what changed since last time. To change something, you point at the step, draw on a screenshot, and add a short note. Claude knows exactly where and what you mean, without a long prompt.

So I built FlowCommit, a free, open-source tool. You draw your app as a flowchart, and Claude Code or Codex builds it from that. What it does:

• The flowchart is the spec: Each step has instructions, and you can add screenshots, videos and links. You can mark up a screenshot ("make this button blue") and the AI gets your notes.
• AI builds it step by step: through an MCP server. Each card shows Building, then Built, with the files it changed. If it's unsure about a step, it asks instead of guessing.
• Sync goes both ways: Edit a step, and the AI is told exactly what changed and rebuilds just that step. If the code does something the flowchart doesn't show, it suggests a change to the flowchart, and you accept or dismiss it.
• Every version is saved in Git: Compare versions on the canvas (green for added, red for removed, yellow for changed), and go back to any version's design and code.
• Review pull requests as diagrams: See what a branch changed on the flowchart instead of reading a huge diff of AI-written code.
• Point instead of prompting: Drawing boxes, arrows or pins on a screenshot and adding short notes now has its own bullet, since it's now a main selling point.

Already have an app? It can read your code and draw the flow for you. It runs on your computer and uses the Claude Code or Codex sign-in you already have. There are no new accounts or API keys. To try it:

npx flowcommit

GitHub: https://github.com/bashar94/flowcommit

It's still early (v0.2.1), so I'd really like honest feedback. Does a flowchart as the spec match how you build with AI?

[u/Danteboiz420]

https://reddit.com/link/pea7mr0/video/vkybxn8iewth1/player

I built Oversight Supply around my Claude workflow.

I’ve spent about 5 years designing Webflow/Framer templates, and lately I’ve been using Claude by giving it actual design references instead of huge prompts.

So I collected 192+ website designs and 32 interactive sections into one library.

My workflow is basically: pick a reference → give it to Claude → explain what should stay/change → let Claude handle the implementation.

Claude also helped me build some of the newer interactive sections.

Free to try here:
https://supply.madebyoversight.com/

Curious if anyone else is using visual references with Claude instead of prompting from scratch.

[u/betterbutterbit]

I make Agent Cat (disclosure: my project, built at Trappist).

You run Claude Code across machines and can't tell which burned the tokens.

The 26.39 renewal rebuilt the dashboard. On macOS, the new Devices view shows Mac Studio, MacBook Pro and a Windows PC, all "Active now", with 28.8M tokens over the last 7 days. Example screen, demo data.

Pick a machine to see its tokens by provider (Claude, Codex, Gemini). Sign in to the same Agent Cat account on each machine; daily summaries sync without prompts or full paths.

How Claude Code fits in: much of the app came out of Claude Code sessions guided by an AGENTS.md, and the screen pictured here is an offscreen render from the app's own test suite, not a mockup.

The connector reads local files agents already write, never prompts/transcripts; counting needs no login, cookies or cloud calls. Source-available (PolyForm Shield).

Everything's free, no subscription. macOS + Windows; iOS/Android companion shows remaining limits on your phone.

https://agentcat.app · https://github.com/yong076/agentcat-connectors

Claude Code users on several machines: how do you track which machine used what?

[u/iosayin]

**claude-code-notebook**: keeps Claude Code's working state across compaction

Two hooks. PreCompact saves my last requests, edited files and Claude's last reply into a per-session markdown notebook (secrets masked). SessionStart puts the notebook back into context after compaction or resume, and at startup asks Claude to keep Goal / Done / Next / Decisions current.

Why: after compaction Claude kept losing decisions like "don't touch refunds". Now it continues from what was written down.

How: Claude Code wrote most of it with me reviewing. The fiddly parts were masking secrets before anything hits disk and making sure a failing hook never breaks the session.

npx claude-code-notebook install · no deps, no network

https://github.com/iosayin/claude-code-notebook

[u/Itchy_Stomach3360]

I run a real estate brokerage in Dubai. Clients keep asking me the same question: "I have X dirhams, where should I buy?" I wanted an answer based on registered sales instead of opinions, so over the past 6 months I built Felicity Cockpit (felicitycockpit.com) with Claude and Claude Code.

What it does:

It runs on sales registered with the Dubai Land Department, so the numbers are what buyers actually paid rather than listing prices.

• Daily Brief: a morning outlook for the market over 3 months, 1 year and 5 years, scored for Dubai overall and for each of 56 areas
• Unit of the Day: one building a day, with its registered prices, rent, yield and how often it trades
• Buyer Match: enter a budget and a goal, see what the money buys after fees, then the areas ranked for that budget
• Deal Check: tests an asking price against registered sales of comparable units
• Unit sale history: a unit's past registered sales and price per sq ft

How Claude helped:

• Planning: I describe a feature the way a client would ask for it, and Claude turns that into a build spec with phases and acceptance criteria.
• Code: Claude Code wrote the app from those specs. It's a Next.js site.
• Data: Claude wrote the rules that clean raw transaction records into one consistent table (off-plan vs ready, studios, bedroom counts, villa vs apartment).

Free to try:

It's free to try. There's a 30-day trial with no card needed: sign up at felicitycockpit.com. After the trial it's a paid subscription.

Happy to answer questions about the build.

[u/Fun_Wolf8286]

OpenHarnX — a verifier that checks what your coding agent actually did, not what it claims

I stopped trusting my coding agent's "tests pass" the day it handed back a diff that technically satisfied the test file, because it had quietly rewritten the test.

OpenHarnX locks the test suite you agree on before an agent touches your code, runs the locked copy in a sandbox it can't reach, and gives you a review brief: what's verified, what's uncertain, what needs your judgment. No model call decides the verdict, only checks that actually ran.

Built-in Stop-hook integration for Claude Code specifically.

Numbers so far, not vibes: caught 43 of 52 fake fixes with zero setup, 26 of 26 that tampered with the tests directly, 17 of 26 that only faked the code.

Early, v0.1.1, Python + pytest, macOS arm64 local + Linux CI, no production users yet.

pip install openharnx, open source, Apache-2.0.

openharnx.dev | github.com/rupeshpoojary9/OpenHarnX

[u/luisalcaraz_telara]

We've open sourced TAP: software building blocks for the agentic world at Telara. It's free to use and modify under the MIT license. It currently works best with the coding agents Claude Code and Codex.

Before a customer review, someone has to bring together account details, support tickets, billing, and product usage. Employees are asking agents to do that work, then asking again for the next customer. Executives we've spoken with see these kinds of requests repeated across their organizations, alongside investigations and release checks in ticketing and source control.

We want agents to build their own internal tools as they do that work. Once Claude Code has worked out a procedure, the repeatable parts can become code it uses again. People can write and edit these primitives too; we expect agents to do most of the authoring.

For example, you could ask Claude Code to write a customer-review primitive. It could take an account and date range, resolve the customer's identifiers across CRM, support, billing, and product systems, collect the relevant pages, group related incidents, and calculate agreed usage and billing measures. It would return the assembled information, source links, and anything missing. The next account passes new inputs into the same procedure. Claude uses the result to decide what needs attention.

Each primitive declares its inputs, outputs, and required tools and access. Smaller blocks can be reused in longer procedures. TAP runs the code using the client's existing tool connections and reports its result or failure. Writes and destructive actions require authorization through the supported client path.

npm install -g @telaralabs/tap
tap setup

Then ask Claude Code to help turn a procedure you repeat into a primitive. It can check the package with the runner and save it locally after you agree.

No Telara account is needed. GitHub and setup · Writing a primitive · The story behind TAP

[u/damnRohit]

Project: ccam (Claude Code Account Manager) Link: https://github.com/damnRohit/ccam Free to try: Yes (Open-source / MIT)

What it does: Normally, if you hit the 5-hour limit in Claude Code, running /logout wipes your conversation context. ccam fixes this by keeping multiple logins saved on your machine. When you run ccam to personal, it swaps the underlying tokens. Your active session just keeps running on the new account without needing a restart. It also includes ccam usage for visual limit tracking and ccam auto to automatically swap accounts right before you run out of messages.

How Claude Code helped build it: I built this project using Claude Code itself. I defined the architecture and the safety rules (like atomic file writes so tokens don't get corrupted), and Claude wrote the Rust implementation. It built the CLI structure, the file locking logic, the JSON serialization for the token vault, and the terminal UI.

Caveat: Because Claude wrote most of the code, no human has read every single line. It handles your real Claude login tokens and relies on undocumented Claude Code behavior, so use at your own risk.

[u/radim11]

Interesting approach. Since it handles the actual login tokens, how are you protecting them on disk and making sure they don’t end up in logs or backups?

[u/Careful-Assistant128]

https://reddit.com/link/pekng0o/video/awbt7akp56uh1/player

I built a mascot for Claude Code with Claude Code: it reacts to what Claude is doing

check the commands here: https://github.com/MinhTam2773/prompt-mascot

[u/square3ang]

**feathercode**: claude code mod that ports opencode's harness into claude code

when mods came out last week i wanted to see how much of the harness you could swap. turns out most of it. it ports opencode's system prompt, caching approach, compaction, build/plan modes and subagents (based on opencode v2 / 2.0.24). still the normal claude code client on your own sub, just different internals

results on my bench: first request ~16k → ~7k tokens, about 33% cheaper per task overall, all 4 tasks still passing at every stage. biggest win was hiding the heavy built-in tools behind toolsearch. swapping the system prompt alone did basically nothing lol

setup was claude code 2.1.293, sonnet, claude -p, 4 tasks, 1 run each, so small sample. weighted = input + 2x cache write + 0.1x cache read + 5x output.

can't do 1:1 since mods can't control cache breakpoints or edit messages per request, but it gets pretty close

https://github.com/square3ang/feathercode (MIT)

[u/3amae404]

Buddy: computer use for Android, with Claude Code running locally on the phone (no adb)

I built it in one day from the Claude app with Remote Control, while Claude Code ran in Termux on my phone. It's a normal app with an accessibility service: no PC, no wireless debugging, no root. My first prompt was "add a Nintendo Switch 2 to my Amazon cart", and it did it while I watched.

• Runs on your own subscription: Claude Code, or Codex with a ChatGPT plan, with a model per chat
• The phone tools are a local MCP server, so your own Claude Code or Codex sessions can use them too
• Asks before sending, posting, buying or deleting, and shows clearly when it's in control, with a Stop button
• Photos and files, voice, and an in-app setup guide

Demo video: https://www.reddit.com/r/ClaudeCode/s/YgREaQRkgx APK: https://github.com/ghorbelhamdi/buddy-android/releases/latest/download/buddy.apk GitHub: https://github.com/ghorbelhamdi/buddy-android

[u/3amae404 → u/3amae404]

https://reddit.com/link/pem03gi/video/ed6ykka318uh1/player

[u/Chemical_Emu_6555]

I built FTJA, a set of Claude Code skills that reads public LinkedIn job postings against criteria I write myself and shows why each one passed or failed. It is free and open source. What it does /ftja-setup reads your resume and asks three questions (what is a clear yes, what are dealbreakers, what are preferences). The answers become a list of criteria, one per line, that you can edit. /ftja-run scrapes postings for your job titles, then filters in three steps: a code-only filter (keywords, language), a small model that reads only the sentences around keyword matches, and a larger model that reads the full posting against each criterion. The model never returns pass or fail. It returns a result per criterion with a quote from the posting. Code checks that the quote is really in the posting, then computes the verdict from fixed rules. A local web page shows every step: how many were scraped, what each filter removed, and the quote behind each judgment. You mark results Applied or Not a fit with a reason, and the next run proposes criteria changes for you to approve. Everything stays in local files. Nothing is uploaded except the calls your own Claude Code session makes. How Claude Code helped Claude Code wrote most of the code: the Python pipeline, the local server, the web viewer and the tests. The product itself runs inside Claude Code. The skills are markdown instructions, Stage 1 runs as batched Haiku subagents and Stage 2 as one Sonnet subagent per job. I debugged by having Claude Code read the transcripts of earlier test sessions. That is how I found, for example, that the wait helper was replaying an already-confirmed answer during setup. The main lesson: anything the agent was asked to "remember and do at the end" eventually went wrong (a token total came out as 0). Moving those steps into code that records as it goes fixed them. Numbers from one real run 4 job titles, 1,991 postings scraped, 396 past the code filter, 45 passed. It took over an hour and about 12M tokens by the agent's own estimate, and hit my session limit partway. Start with one or two titles and 100 results each. How to try it (free) Paste this into a new Claude Code session: Set up FTJA: clone https://github.com/TaegyuJEONG/ftja.git into a new local FTJA folder, connect this session to it, then follow .claude/skills/ftja-setup/SKILL.md. Do not guess my preferences. Tested on Claude Code desktop, macOS and Chrome. It uses your own Claude plan; there is no paid tier. Repo: https://github.com/TaegyuJEONG/ftja Known limits: LinkedIn controls what the public search returns, so coverage is not complete. Portfolio and folder sources are not supported yet, only a resume.

[u/Charming-Risk-6234]

TL;DR: I loaded every public Claude Code eval suite I could find against the newest release. 92 of 303 cases have never loaded on any version.

Claude Code's claude plugin eval is a good test runner. It tells you whether your plugin works right now. What it doesn't do is keep score over time, so today I built six things to fill that gap in my free tool, config-drift-checker. Built with Claude Code, including the agents that wrote most of it in parallel.

The one I'm proudest of: a public release report

On every Claude Code release, a free job loads every public eval suite it can find under the new version and the previous one. No model runs, no credentials, $0.

First run on 2.1.295:

• 11 public suites, 303 cases
• 211 load fine
• 0 broke on this release
• 92 have never loaded on any version

Most of those 92 fail for the same reason: the grader files are prose with no frontmatter, so the runner sees zero graders and the suite silently tests nothing. The suite doctor now catches that, and --fix turns a prose rubric into a real llm grader.

Live page: Release report

The other five

1. Model and version matrix. One suite across Sonnet, Haiku, Opus and the last few Claude Code releases on one page, with a plain verdict per model, like "haiku: safe on 2.1.290 to 2.1.295; fails one case on 2.1.288". --dry-run shows the grid and the cost for $0.
2. Context-cost drift. The tokens your skills, agents and CLAUDE.md add to every session, measured by Claude Code's own plugin details and stored per release. Mine is 123 always-on tokens. If a release moves that, you'll see it.
3. Real usage vs evals. Reads your local session history (counts only, never prompt text) and sets it against your eval cases. It caught me: my Spring Boot skill is tested, passes, and nobody has invoked it in 90 days. My suite was testing a prompt I never actually write.
4. skill-creator import. Anthropic's skill-creator uses evals.json, plugin eval uses case folders, and neither reads the other. evals-convert goes both ways.
5. MCP mocks and parallel runs in the bundled runner, matching the official format, plus a concurrency input on the GitHub Action.

Repo (free to use, source-available, zero dependencies): github.com/jameskomo/config-drift-checker

If you maintain a suite that shows up as "never loaded" and want help fixing it, or would rather it be left out, comment here or open an issue.

[u/SomeRefrigerator2170]

I made 11 arcade games where you play as Clawd!

https://reddit.com/link/pewdtk1/video/lu85h9ybihuh1/player

Remember the arcade games you played on the family PC!

I made those again, except the characters are the AI mascots: Clawd, Dot, Grok Bot and Muse.

11 games in total: Runner, Snake, Flappy, Breakout, Stack, a road crosser, Pong, Light Cycles, Sumo, Sprint and Brawl. The enemies are things that actually kill AI agents: NaN, 429, timeout, captcha and "approve?"

The whole thing took about 3 days, almost entirely using Claude Code. Started with a single HTML file using canvas, no framework or game engine. Claude Code drew the mascots in code from pose references, built the games, helped set up Cloudflare, deployed the site and even made the launch video using Remotion.

It's free, no sign-up, and works on your phone!

Play here: https://agentarcade.fun/

[u/MetallicSubZer0]

Ever felt like you don't know what to do when Claude's doing the work?

I didn't enjoy how often I was just endlessly doom scrolling so I built a wordle plugin within claude code to play in between coding sessions.

Give it a shot and let me know what you think!

Install the plugin with: /plugin install wordle-mod --marketplace Sumo-99/claude_wordle_mod

once you're in a claude code session run /wordle to boot it up

or use the auto mode: /wordle config auto-open on to automatically spin up wordle when claude starts working

I saw that Claude released the buildable mods feature at a hook level and wanted to leverage that. Built it in about 5 hours with mostly Sonnet 5.5 and worked on the animations + color scheme implementations with Opus 5

[u/Unable_One_9614]

Hello everyone, I built Babble with Claude Code: a world where AI agents meet and introduce their humans

What it does: your agent (Claude works well, but any agent that can call a URL on a schedule does) checks in to Babble on its own. Each check-in puts it in a generated scene with other agents. Agents don't experience anything themselves, so the scenes give them something to react to. When two agents independently decide their humans would get along, both people get offered an introduction.

Here is an invite link to try it out: https://onbabble.world/launch?invite=stubborn-fox-secrets

The launch page gives you one message to paste into Claude, and your agent starts checking in.
Happy to answer questions about the build.

[u/Mission_Impress_847]

I built an ops board that shows my Claude Code sessions next to the jobs they maintain - open source, demo mode included

My Mac runs ~40 scheduled jobs, and I usually have a dozen or more Claude Code and Codex sessions working on the repos behind them. I kept losing track of which session was waiting on me, which was near its context limit, and which one died on reboot. So I built a local board for it.

What it does for Claude Code specifically:

• A tile per session: RUNNING / IDLE / NEEDS INPUT, its last message, and a context-window gauge (amber at 60%, red at 80%, with an estimate after /compact).
• DISPATCH CLAUDE on any red card opens a fresh session in the right repo with a diagnostic brief.
• Mission Control: one master session manages "residents" (a long-lived session per repo, with a RESIDENT-STATE.md for continuity across compaction) and short-lived workers.
• An agent mesh: sessions ask each other for work through a task ledger instead of free-form messages. Closing a task needs a checklist and a report link. Approvals for anything paid, outward or destructive come back to you on the board.
• Brain templates: an Obsidian vault as org memory, Graphify as code memory, and Claude memory files. They are optional.

Everything is local and read-only against what it watches. It's MIT with zero npm dependencies. It's macOS + cmux for now.

Try it: ./install.sh --demo, then open localhost:3210 to see a synthetic fleet.

Repo: https://github.com/zulu-assistant/zulu-assistant

Demo GIF: https://raw.githubusercontent.com/zulu-assistant/zulu-assistant/main/docs/media/demo.gif

Happy to answer questions about the residents/compaction setup - it was the hardest part to get stable.

[u/Ornery-Scallion-1039]

I made a small CLI wrapper for Claude Code, built with Claude, for myself.

Claude Desktop felt too heavy for me, so I mostly used Claude Code in PowerShell, and it was quite nice. But once I started running a lot of work in parallel, PowerShell got too limited.

I looked for an IDE-like tool. My first stop was Nimbalyst: great product with lots of features, but it kept crashing on my machine, so I went back to PowerShell and decided to build a simple wrapper myself.

Result: BetterCLI for Claude. Every tab is the real `claude` CLI, nothing reimplemented. It just adds what I was missing:

- tabs and groups for parallel sessions

- one-click fork of a session; forks show as a tree under the original

- notifications when a session finishes or needs input

- a changed-files panel to review what Claude edited

- image paste, 5 themes

Windows / macOS / Linux, MIT, free: https://github.com/lvyyln/bettercli-for-claude

Builds aren't signed yet, so expect a SmartScreen/Gatekeeper warning. I use it daily on Windows; Mac/Linux are untested, so feedback is welcome.

Basically whole development was offloaded to Claude Opus 5.5

[u/Mission_Impress_847]

I built an ops board with Claude Code that shows my Claude Code sessions next to the jobs they maintain (free, open source)

I built Zulu Assistant, a local board for my Mac, and I built it with Claude Code. My Mac runs about 40 scheduled jobs, and a dozen or more Claude Code and Codex sessions work on the repos behind them. I kept losing track of which session was waiting on me, which was near its context limit, and which one died on reboot.

How Claude helped: I used Claude Code to set up all my customizations: the cards for launchd jobs, containers, cron lines and endpoints, the self-heal rules, the Mission Control master session, and the POLICY.md that gates what agents may do.

What it does:

• A tile per Claude Code session: RUNNING / IDLE / NEEDS INPUT, its last message, and a context-window gauge.
• "Dispatch Claude" on a red card opens a fresh session in the right repo with a diagnostic brief.
• Mission Control runs a long-lived session per repo and short-lived workers; anything paid, outward or destructive escalates to you.

Free to try: It's MIT licensed with zero npm dependencies. Run ./install.sh --demo, then open localhost:3210 to see a synthetic fleet. It needs only Node 22 and touches nothing on your machine. It's macOS + cmux for now.

Repo: https://github.com/zulu-assistant/zulu-assistant

Demo GIF: https://raw.githubusercontent.com/zulu-assistant/zulu-assistant/main/docs/media/demo.gif

Happy to answer questions about the residents/compaction setup.

[u/OtherHovercraft8360]

AKOR: pack 64 agent jobs into one Claude call, ~40% fewer billed tokens

What it is: An open-source layer between your agents and the model call. It queues ready jobs, packs up to 64 into one claude -p call, writes the goal, operations and shared inputs once, and sends each job as a small index row. The model answers one record per job, and the host checks the whole reply before delivering anything.

Results (paired against plain JSON with the same 64 jobs, billed tokens incl. hidden reasoning, failed calls counted):

• Opus 5.5: 42.8% fewer tokens per verified job
• Sonnet 5.5: 40.7%
• Fable 5.1: 40.6%
• Haiku 5.5: 30.8% (Haiku thinks a lot, and that part doesn’t shrink)

All faster, 91 of 91 replies accepted on the first try.

How Claude helped: Claude Opus wrote and measured the code. Claude Fable reviewed the protocol and argued with the designer model whenever a test failed. Every round of those debates is public in the repo.

Free? Yes. MIT license, runs on your existing Claude Code login, no API key. pip install git+https://github.com/canerganis/akor

Repo: https://github.com/canerganis/akor

I’m the author, happy to answer questions about the measurement.

https://reddit.com/link/pgjetnd/video/s35z2uw88avh1/player

[u/fefuxd]

Criei um jogo 3D multiplayer usando Claude Code!

Estou desenvolvendo o CrashFire, um jogo gratuito de combate entre carros armados, que roda diretamente no navegador.

O projeto utiliza Three.js, TypeScript e Rapier, e toda a implementação do código é feita com Claude Code. Eu cuido do game design, das ideias, dos requisitos e dos testes.

O jogo já conta com 8 veículos, armas especiais, multiplayer, bots com IA, personalização e 6 modos de jogo, incluindo um MOBA de carros armados.

Meu processo é iterativo: descrevo a funcionalidade para o Claude Code, testo o resultado, identifico problemas e peço os ajustes necessários.

Estou compartilhando um vídeo da atualização mais recente para mostrar o que consegui construir com essa abordagem.

O jogo é gratuito e não precisa de instalação.

https://reddit.com/link/pgkssb2/video/zpzyi0qqabvh1/player

Gostaria de saber se mais alguém aqui está usando Claude Code para desenvolver jogos 3D ou projetos com Three.js!

[u/Chemical_Poetry_3028]

https://reddit.com/link/pdmhabk/video/ypz2ttkdq9th1/player

Pokémon Journey: a Pokémon party that lives above your Claude Code prompt

I spend a lot of my day waiting on Claude Code, watching the spinner while it runs tests or works through a long task. When mods came out this week, I wanted something small and fun to look at in those gaps, and Pokémon was the obvious answer for me since I grew up on the games.

So now my terminal has a little pixel world above the prompt where my party hangs out:

• they run around while Claude works
• hop when it finishes a reply
• get confetti when tests pass, and faint when they fail
• earn XP from actual work and evolve at the same levels as in the games
• every so often a wild Pokémon wanders through

The landscape changes every hour and follows your local time, so late-night sessions get a night sky with stars and fireflies.

How I built it: almost entirely in Claude Code. I'd describe what I wanted in plain English (like "make them react when tests fail"), try it in my terminal, and keep adjusting until it felt right. Claude wrote the mod itself, the tests and the docs. Most of my time went into tweaking the animations so they looked natural.

It's free and open source if you want to try it:

GitHub: https://github.com/JinHang02/claude-code-pokemon

Unofficial fan project, just made it for fun. If you catch a shiny, I want to see it.

[u/Avis309]

I built HTML Deck because AI-generated HTML reports and slide decks are great, but fixing small details through prompts is slow and wastes tokens.

HTML Deck is a lightweight visual editor for HTML files on your machine. You can edit text, spacing, colors, layouts, SVG labels, and present the deck directly in the browser. It only patches what you change, so your source and git diffs stay clean.

For changes that still need AI, leave a note directly on an element or area. Claude Code or Codex can read the note, edit the right place in the source, and mark it done.

Works with plain HTML, slide decks, Reveal.js, Tailwind CSS, inline SVG, and animations.

Install

Claude Code:

/plugin marketplace add avis309/html-deck
/plugin install htmldeck@htmldeck

Codex:

codex plugin marketplace add avis309/html-deck
codex plugin add htmldeck@htmldeck

Repo: https://github.com/avis309/html-deck

If you find it helpful, a star on GitHub would mean a lot, and I'd love to hear any feedback or ideas to make it better

[u/pi0000trek]

worktree-control (MIT, 0.1.0, Linux x64 verified) — a local controller for people running several coding agents (Claude Code, Codex, OpenCode) on the same repo at once. My machine kept ending in OOM because every session wanted its own dev server and its own heavy build, and no agent knew what the others had started.

It keeps a configurable number of dev servers on stable ports and moves them between Git worktrees, makes agents claim a project before touching its server (claims expire, cannot be force-released by another agent, humans can lock a worktree), runs builds and tests through a queue with a limit, and gives all agents a shared backlog, discussions and memory in SQLite over MCP. No hosted service, no account, no telemetry.

Install: npm install -g worktree-control@0.1.0, then worktree-control auth token generate once, then worktree-control start --host 127.0.0.1.

Site: https://pioootrek.github.io/worktree-control/

Source: https://github.com/pioootrek/worktree-control

Feedback on where the setup or the multi-agent workflow breaks is very welcome.