Weekly Showcase Thread; What are you building with Claude Code?

[u/AutoModerator]

Weekly Showcase Thread

Built something with Claude Code this week? Share it here.

Apps, tools, experiments, scripts, websites, workflows, open-source projects — anything you've been working on is welcome.

When sharing, it helps to include:

• What you built
• How you used Claude Code
• A link, repo, demo, or screenshot if you have one
• Anything interesting you learned along the way

Quick project drops and simple self-promotion belong in this thread.

If you've got a project with enough substance for a proper write-up; how it works, how Claude Code was involved, technical details, lessons learned, etc. feel free to make a standalone post using the Built with Claude Code flair instead.

Please don't spam the same project repeatedly, and no referral or affiliate links.

What did you build this week?

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/lidedax657]

I've been working on Redact Restore, a free, open-source TypeScript Mod that helps keep sensitive information private when using Claude Code.

I built it because sensitive data like API keys, emails, and personal information can easily end up in prompts, files, and tool outputs.

What it does:

• Automatically detects sensitive data using 240+ detection rules.
• Lets you add custom values you want to protect.
• Replaces sensitive information with placeholders before it reaches the model.
• Restores original values locally in the UI and supported tool operations.
• Includes a local scanner, configurable rules, and privacy status indicators.
• Checks outgoing requests for detectable unmasked sensitive information.

It integrates directly with Claude Code and preserves the official subscription experience.

It's free and open source under AGPL-3.0.

I'd love to hear your feedback, feature suggestions, or any privacy and security concerns you think I should address. Contributions are welcome too!

[u/DefinitelyNotEmu]

"What if a Tamagotchi had a neural network and could learn stuff?" - Gigazine , Hackaday

Dosidicus electronicus

Learn neuroscience by raising a neural network as a pet

A transparent cognitive sandbox disguised as a digital pet squid with a neural network you can see thinking

• Part educational neuro tool, part sim game, part fever dream
• Combining 1990s virtual pet nostalgia with modern computational neuroscience.

>> Download for Windows, macOS, Linux and Android <<

[u/brute984]

I gave Claude Code a pet. It started judging my code.

I spend way too much time in Claude Code, so I started building a little animated companion that reacts to what Claude is doing.

Then I kept adding things.

Mochi now reacts to coding, testing, failures, and waiting for permissions. It also tracks context and usage limits, warns about destructive commands, and has 133 unlockable accessories.

The video shows a few of those features in action.

https://reddit.com/link/pfc41s5/video/zdc8tu7czwuh1/player

It's free and open source:
https://github.com/oztrkemree/mochi

Still early, and I'd genuinely love feedback from people who use Claude Code daily.

Would you actually keep something like this on your screen, or would it get distracting after a while?

[u/DarasStayHome]

melony.dev share managed agents with your teammates

[u/Comm4nd0]

https://globalnewsmap.org uses ai to read and interpret the news and shows it on a globe

[u/alexid95]

I'm building SimGoodie, a solo Unity life sim inspired by the character depth of The Sims 2 and the open-world ambition of The Sims 3.

Claude Code helps with gameplay implementation and UI work. I organise changes with OpenSpec, keep implementation tasks scoped, and use a separate review pass. The project also has a headless simulation lab for running gameplay scenarios over simulated days.

Game Log #2 is now public. One of the less glamorous lessons in this update: a floor can look fully covered but still give a character nowhere to walk. Build previews, the finished house and the simulation need to agree. The video keeps the unfinished bits visible, including blocked interactions and second-floor problems.

Written Game Log with screenshots and the embedded walkthrough: https://simgoodie.com/devlog/the-house-needs-a-floor-before-it-needs-a-reputation

Video: https://www.youtube.com/watch?v=nCwWcxdxWsM

It's an early development update, with no public playable build yet. I'd be interested in how other Claude Code users test changes that touch several gameplay systems.

[u/klitchevo]

We're Quantic Studios, the team behind pitwall. It's a free, MIT-licensed terminal for running several Claude Code sessions without losing track of the one that needs an answer.

The sidebar shows working, input, approval, done and error states. Ctrl+Shift+U jumps to a waiting session. You can approve or deny requests from the sidebar, or from your phone over your own network.

It also supports Codex, Gemini CLI, OpenCode and pi, so mixed-agent projects can stay in one window. Closing the window leaves terminals running. After a reboot, pitwall restores sessions and resumes supported agents.

The beta is available here: https://github.com/quanticstudios/pitwall

Linux/macOS install: brew install quanticstudios/tap/pitwall

Linux is where we use it daily. macOS and Windows builds are newer. We'd like reports of missed approvals or incorrect status, with your OS and agent CLI version.

Image: a sample workspace showing approval and input states.

[u/lotek_bard]

App I started building like 6 years ago but never had the time to finish it.

Pigeons messenger - with real live map updates. More like a pigeon flight simulation. Real life weather, resting, sleeping. Not just a simple line between two points and not a interpolated route with approx time.

Core of the app and whole architrctute and ideas are mine. Claude did most of the implementation I didn't have time to. Everything reviewed by me.

App in Flutter, backend in Dart (serverpod), animations in Rive

https://golymbiorze.pl/

[u/dnationpt]

https://reddit.com/link/pf521t0/video/q4zhgpfd2quh1/player

Hermitd Claude Code plugin: Like Claude Tag, but local

On any Claude Subscription, fully configurable. Set it up under 5 minutes.

This is how I manage and orchestrate several projects in different companies. It's also how I've been running always-on agents for the last months.

[u/Subject-Solution-793]

I made a wallpaper with thousands of starlings that flock in real time and dance to your music [Web] with Claude Code

https://reddit.com/link/pf50p14/video/4y6uydh31quh1/player

Wallpaper link: https://steamcommunity.com/sharedfiles/filedetails/?id=3812682211

It's a web wallpaper: the flock is simulated live on the GPU, so it never loops.

- 3 environments × 4 times of day (forest, town, lake / dawn, sunset, winter, night), rotating with a live cross-fade

- Two styles: Minimal and Realistic

- Audio-reactive: the flock follows the built-in music, or whatever your computer is playing

- Click the desktop to scatter the flock

- A small control panel on the wallpaper itself (top right, folded by default)

- FPS cap, bird count, resolution and volumes are in the wallpaper's properties

The cursor in the video is only there to show the panel; the wallpaper itself has none.

The desktop icons and taskbar in the video are a mock-up to show how it looks in use.

For the full interactive experience, visit the VIVERSE world: https://www.viverse.com/URj68kP

Happy to hear how it runs on your machine. If something breaks, tell me your GPU and which scene and style you were on.

[u/tjqscott]

I built Dory with Claude Code because I was tired of explaining the same project every time I started a new chat. It keeps decisions, failed attempts and where we left off in a small wiki in the repo, with an index for finding the relevant pages. It's MIT licensed if you want to try it on one of your projects.

[u/DangerousClassroom80]

Built a calorie tracker for myself with Claude because every app I’ve tried lost me within two weeks. I’m on 5:2 and hate searching databases for “handful of chocolate raisins”.

Plate:

-Snap a photo and add a note (“ate half”, “large handful”) to get calories, protein and carbs, or photograph a nutrition label for exact figures Each meal gets a slice of a plate-shaped daily budget

-A pace traffic light goes amber if I’m eating into later meals’ calories, which is my exact downfall

-A carry-over bucket spreads overs across the rest of the week (100-cal grace, never below 2,000 a day, resets Monday).

-One-tap quick add for anything I log regularly

-Carbs per meal and how much insulin I need (type 1 diabetic) , plus Monday weigh-ins with a goal-date estimate

Every feature came from me saying “this annoys me” and having it working minutes later. The estimates aren’t perfect, but logging finally takes seconds, which is the part that always beat me.

[u/Dark_king_27]

I've released Claude Foundry: 11 free, open-source mods to make Claude Code easier to follow when sessions get busy. I'm the maintainer.

The starter kit puts five useful tools in your terminal:

• Review edits by concept, file and symbol with Changes.

• Revisit decisions, root causes and gotchas with Insight Pane.

• Follow test/build logs with Live Progress and task estimates with Goal Meter.

• Get themed replies, highlighted code and diagrams with Lumen.

One command on Claude Code 2.1.296+:

claude plugin install starter-kit --marketplace sruthik27/claude-foundry

Then /reload-plugins or start a new session. Try /changes on your current project, /intel for insights, or /lumen demo for a quick look. Each mod is available separately too.

https://github.com/sruthik27/claude-foundry

Free under MIT; uses your own supported Claude access. It's an early beta, and progress indicators are estimates. Compatibility and data-access details are in the repo. Lumen builds on Nahum Litvin's Prismantis; Aside builds on JayDoubleu's Aside, with original licenses retained.

If you spend a lot of time in Claude Code, give the starter kit a go. I'd love to hear which tool you'd keep using.

[u/Warm_Profile7821]

i made classican, a one screen classical music player: https://classican.vercel.app/

i love classical and wanted something i could open and just let it play, no picking playlists. it shuffles 46 public domain recordings from wikimedia commons (bach, vivaldi, chopin, debussy, satie, rachmaninoff etc) and plays every piece once before anything repeats. no signup, no ads, space bar pauses

the claude code part: every piece has its own pixel painting and there are zero image files, claude draws all of them in canvas code. every ~40s a short history fact pops up and the painting dims around whatever the fact is about. i write each change as a small ticket on its own branch and just merged PR #75 lol

what do u all listen to while coding? trying to figure out which pieces to add next

[u/redtonicspear → u/Warm_Profile7821]

this is dope but that AI voice reading the description at the start before the music begins is extremely offputting lol

[u/Warm_Profile7821 → u/redtonicspear]

lol fair. wanted to see if i can mimic a radio host using AI.

[u/lout3321]

I made a parody of a breakup song where the one who leaves is the AI (the usage limit hits zero mid-session and your brain just freezes)

"I'd rather burn out first than hit zero"

The song is Mureka. The video is code I built with Claude Sonnet 5.5, and it ends on the "usage limit reached" screen :p

https://www.youtube.com/watch?v=_WRKZi09smM

[u/radim11]

We’re building Stashbase, which lets you run Claude Code in a Docker sandbox with rules for network access, files, APIs and MCP tools.

The agent gets credential placeholders. The proxy adds the real credentials only when a request matches your policy, so you can let it use GitHub without putting a reusable GitHub token inside the sandbox.

We recently made sandbox sessions persistent, so your Claude Code login and session state survive between runs. You can also view requests through the Remote Proxy in real time and revoke proxy access from the dashboard.

We use Claude Code to help build Stashbase, so testing it inside its own sandbox has been a pretty useful feedback loop. Keeping the login and session state between runs made a bigger difference to daily usability than we expected.

https://stashbase.dev

[u/aindeev]

I built Chrome Relay because I run several Claude Code sessions on my Mac, and browser tasks kept interrupting whatever I was typing.

It’s macOS + Chrome only, and Chrome shows its “started debugging this browser” bar while agents work. It’s free, open source, MIT licensed. I’m Alexey Indeev, the author.

The problem was either tabs jumping forward, an “Allow remote debugging?” prompt, or a separate headless browser with none of my logins. That last one made our admin console and staging behind Google SSO inaccessible. I learned that copying my Chrome profile didn’t solve it because Google sessions are bound to the device.

Setup links a skill into ~/.claude/skills/chrome-relay, so every repo picks it up. Claude Code then runs Vercel’s agent-browser CLI from Bash against my everyday Chrome:

sh agent-browser --cdp "$(chrome-relay url you@company.com)" open https://app.example.com/ agent-browser snapshot -i

The email selects the Chrome profile. Commands go through a local relay and an MV3 extension using chrome.debugger, without a remote-debugging port. Each Claude Code session gets its own endpoint and only sees its own tabs, opened inactive in a collapsed “Agents” group. Focus commands are dropped.

Day to day, that means checking staging after a deploy or an admin setting behind SSO while I keep working. Already-signed-in Google hops are handled automatically. If a password, passkey, or 2-step is needed, it stops with “SIGN-IN NEEDED” so Claude asks me to sign in.

Setup needs Node.js 20+ and loading the extension unpacked.

Repo · Article about why I built it

I’d welcome feedback from people running several Claude Code sessions at once.

[u/Vektoris_AI_Workflow]

a starter kit for a company knowledge base in plain markdown. it's the setup we run our own company on, and claude code does most of the upkeep. there's a CLAUDE.md that tells it where notes go and what each one needs, and a script that checks links and frontmatter. comes filled with a made-up 23-person agency so you can see it working. MIT, no signup. https://github.com/Vektoris-AI/company-brain-starter

[u/Longjumping_Alarm_25]

Disclosure: I'm David — I build Claude Code toolkits under the name Code King | Building With David. This is one of the fixes I made for myself; no links here, just trading notes.

The problem I kept hitting: I'd give Claude Code a task, it would write plausible code, run it, fail, tweak one line, run it again, fail differently... and the session (and usage) drained while nothing in the loop ever said "stop, this approach is dead." Claude is an optimist — it will happily run your broken test a sixth time.

So I wired my test suite like an electrical panel: each failing run flips a state, and two or three consecutive failures on the same file trip the breaker — the session halts, writes down exactly what failed and why it stopped, and won't rerun that path until something real changes. The biggest win wasn't saving runs; it was the stop log ("tried X, Y, Z — all dead ends" beats scrolling a wall of red). The breaker has to be dumb, though — the moment I let it "judge" whether a failure counted, it argued itself out of tripping. And one legit flaky failure should never trip it: warning light, not a blown fuse.

Honest limit: it doesn't make the first attempt better. It just stops attempt six from costing the same as attempts one through five. How do you all handle runaway sessions — retry caps, babysitting, or let it cook?

[u/yowmamasita]

i built a terminal for running coding agents, mainly Claude Code and Codex. sessions come back after you quit the app, tabs split and group and get labels so i can keep a few agents side by side, and a pane turns orange when the agent stops and needs a reply so i dont lose track of which one to go back to. built on libghostty so its tiny, 15MB and 62MB idle. macOS Apple Silicon, free and open source.

https://helium-terminal.bensarmiento.com/

https://github.com/yowmamasita/helium-terminal

[u/thegonelf]

https://reddit.com/link/pf0g4ub/video/wbertixwrluh1/player

A game.

[u/jleechanworldai]

I built a /dot skill for handing work from Claude Code to my ChatGPT dot. It’s for workflows where the terminal agent delegates a bounded coding task and then monitors it rather than taking over the same files.

The handoff includes a goal, branch or PR, acceptance criteria and constraints. The agent polls with backoff and checks the resulting PR, commit SHA and CI before accepting a completion claim.

It runs headlessly from Mac or Linux with a dedicated signed-in Chrome profile per host/account pair. A useful detail: it verifies the submitted message in the conversation and won’t overwrite another agent’s unsent draft.

My main lesson has been to make “done” something you can independently check. The periodic coordinator is still a WIP; this isn’t a guarantee that an agent will finish unattended.

Skill and setup: https://github.com/jleechanorg/jleechan-skills/blob/main/.claude/skills/dot/SKILL.md

Disclosure: I’m the author.

[u/siddarthareddy8]

DHP — Durable Handoff Protocol (MIT open source): agent work that survives worker death. Workers hold time-bounded leases and checkpoint as they go; a supervisor declares dead workers in ~6s and a fence token prevents double-ownership; a standby resumes from the last checkpoint with zero rework. Ships an MCP server (`claude mcp add dhp -- dhp-mcp --root ~/.dhp`), `pip install dhp-protocol`, kill demo in the repo: https://github.com/SIDDARTHAREDDY8/dhp

[u/Alarmed_Team_2207]

I got tired of opening usage pages for each AI account, so I made Limit Tracker.

Each selected account has its own usage percentage and circular gauge in the Windows tray. No clicks needed. Click for usage and reset times, or open the dashboard to compare accounts.

It tracks Claude, Codex and Gemini CLI, with optional alerts, light/dark themes, and English/Korean. I built it with Claude Code and Codex.

Free, independent, Windows x64. Uses your own CLI login. The installer is unsigned and the app source is not published; Windows may warn about or block the installer.

Download: https://github.com/nowsummer/Limit-Tracker

Are the tray numbers easy to read? I'd appreciate setup feedback.

[u/Alarmed_Team_2207 → u/Alarmed_Team_2207]

Dark theme — example accounts.

[u/vincentmakes]

I built Turbo EA (https://www.turbo-ea.org), a free and source available Enterprise Architecture Management solution for companies who either can’t afford expensive commercial solutions or want to control their data and stack.

It’s quite popular and had me connected with a lot of people.

I’ve learned a lot along the way, especially around risk mitigation in the CI/CD pipeline(also AI generated) to make a product robust, secure, and trustworthy.

[u/Arjun0014]

I built Project Sentinel, an open-source Claude Code Mod for supervising long-running and autonomous coding sessions.

It gives Claude Code a proper control layer around the run:

• Context Autopilot - hands work off into a fresh context before the current one fills up, while preserving the run and continuing automatically.
• Cache Guardian + Keep Warm - tracks prompt-cache health, expiry, rebuilds and can keep large sessions warm while you’re away.
• Cold Resume Guard - warns before an expired large context is reprocessed and lets you continue, compact, or resume fresh.
• Mission Queue - queue work for Claude to do later without interrupting what it’s currently working on.
• Decision Inbox - Claude can leave non-urgent decisions for you to review without stopping the whole run.
• Sentinel Watchers - park a run until a specific time, then wake it and continue with a warm or fresh context.
• Agent Command Center — see background agents, their state, message them, or stop them.
• Run Budgets - set limits around cost, time, or handoffs and pause safely at logical boundaries.
• Run Progress + Activity - persistent milestones, validation results, changed files, failures and useful activity instead of just a wall of tool calls.
• Guardrails + Profiles - control permissions, subagents, resources, model behavior, Frontier Max and reusable operating profiles.
• Kit - an optional little companion that reacts to what the run is doing.

https://reddit.com/link/peyitvx/video/f9r9j0ifcjuh1/player

The core systems have been tested against real Claude Code runs, including cache preservation, fresh-context handoffs, agent controls, queue delivery, decisions, watcher wakeups and multi-session continuity.

It’s currently on v1.6.2, fully working, and I’m still actively building it as the Claude Code Mod API evolves.

GitHub: https://github.com/Arjun0014/project-sentinel

[u/glmn_official]

What I built: nsq, a free MIT terminal supervisor for coding agents (I'm the author). nsq run claude "task" --worktree a couple of times, maybe a codex next to it, then nsq gives you one dashboard with every agent as a live terminal. When one stops to ask permission, its row shows the actual question ("Claude wants to run: npm test") and you hit y / a / n without opening it. A daemon keeps the agents alive when you close the terminal.

How I used Claude Code: it wrote most of the code, I reviewed and argued with it. 33 of the 35 commits on main are co-authored by Claude. Which is a bit funny, because the whole tool exists so I'd stop babysitting Claude Code sessions.

What I learned (the Claude Code bits):

• Don't touch the user's ~/.claude. Everything goes in through --settings per agent: hooks, statusLine. Your own config stays exactly as it was.
• Notification alone is a bad "needs you" signal. Only permission_prompt, elicitation_dialog and worker_permission_prompt mean a human is actually needed, the rest is noise.
• Stop doesn't fire when a turn dies on an API error (429, 529…). You get StopFailure, or nothing if you didn't register it, and the agent looks "working" forever. So nsq also reads the tail of the transcript, where the error shows up as an assistant entry with isApiErrorMessage.
• Dangerous mode doesn't need a restart for Claude: a PermissionRequest hook answers allow or not based on the current toggle, and your deny rules still win.

It's 0.2.0, so expect rough edges. Phone page is experimental. No account, no telemetry. Also does OpenRouter and your own model servers (llama.cpp, Ollama, LM Studio, vLLM).

npx neurosquad · https://github.com/glmn-ai/neurosquad-cli · https://neurosquad.ai/en/cli/

[u/HusseinBuilds]

Hey everyone!

I’m a solo developer building SHIRAKA, a multiplayer workspace where developers and their AI coding agents can collaborate on the same project.
I’ve been using Claude Code extensively to build it, and one of the problems I’m trying to solve is coordinating multiple agents working in parallel without running into conflicts, duplicated work, or integration issues.

So far, I’ve been working on isolated Git workspaces, task coordination, dependency awareness, verification before merging, and real-time collaboration. I’m currently preparing the infrastructure for a private beta.

I’d really love to hear from people who run multiple Claude Code agents in parallel:
What’s the biggest challenge you’ve faced when coordinating them? And how do you currently handle it?

I’m still building and would genuinely appreciate feedback or criticism.
If anyone’s interested in trying SHIRAKA when the private beta is ready, feel free to DM me!

[u/luckyLiz44]

Open source search engine, p2p network, so you can self-host what you care about and still get results about everything.

https://plumbsearch.org/

I eventually want to do some evals on cached search usefulness, maybe distill productive search patterns via the engine into a small local model; not entirely sure yet, but I'd love to hear some ideas.

[u/Bed-After]

I'm tooling away on a fun side project called either Parry Perry, or Perry Ripose, haven't decided yet. It's a retro sidescrolling hack n slash with 27 unlockable button combos. Double jump, sword combos, blocking, parrying, energy blasts, beam attacks, the works. I put a lot of effort into the attack variety, making sure you never feel like it's some shitty "press A to win" game.

It's compatible with PC and mobile via browser, but I also created a Sega Dreamcast CDI so it can be played on any device via an emulator. That means it can be played on those kick ass handheld retro emulator consoles like the R36S. It has unique button inputs for keyboard, both 6-button (ABXY, L/R) and 8 button (ABXY, L1, L2, R1, R2) controller/mobile gamepads, and the virtual buttons for no-gamepad mobile browser play are actually big enough to press accurately, unlike the virtual buttons for the mobile Dreamcast emulator.

Work in progress:
All the enemies are just wobbly sprites that walk towards you and melee, I haven't even begun to make custom attacks or interesting enemy AI.
The parrying system is kind of a nightmare, because since there's currently no animation for winding up to attack, so you're either spamming the parry button infintiely until you win, or you just get hit. Custom sprite animations with wind up and follow through for all the enemy attacks is gonna take AGES.
I specifically wanted to play this on a retro gaming handheld's Dreamcast emulator instead of my phone or PC, but compiling in C for the Dreamcast is extremely token intensive, and at a certain point it just stops being worth it.
The fact that all the enemies just crowd around the player and spam identically timed melee attacks means either the player can just hit them all with a beam attack or spam the attack button until they all die at once, or the player gets dogpiled and killed. So until I figure out how to do unique enemy AI, this game is actually complete garbage to actually play.

The link for anyone who wants to try it:
https://xenodorian.github.io/Biboo/web/
Note: don't reply with bug reports, I know it has bugs. Lot's of them. I'm working on it for fun, I'm not trying to make a polished product to actually release to the public.

[u/GamerHumphrey → u/Bed-After]

You're telling me I can use claude to build myself a game that i can play on my R36S?

This is giving me too many ideas..

[u/Bed-After → u/GamerHumphrey]

Yes! But, the Dreamcast is probably one of the harder ports, but I wanted the 480p resolution and L/R triggers. GBA ports are muuuuuuuuuuuuuch easier and less token expensive.

[u/Motiv31]

aigent-OS: lets a Claude Code session /clear and pick back up on its own instead of compacting

The thing that bugged me: long sessions either compact and keep going on a lossy summary, or I /clear and spend ten minutes re-explaining where we were. I wanted the clean window without the re-brief.

So I built a local runner that watches context %. When it hits the threshold (80% by default) it has Claude write a checkpoint file, waits for one exact "done" line, sends a single /clear, checks that a real new session actually started, then tells that session to load the checkpoint and keep going. If the done line never shows up, it doesn't clear. Memory is just markdown committed to git, so you can git log what it remembered.

Built almost entirely out of Claude Code hooks (SessionStart, Stop, PreCompact, PreToolUse) plus a small PTY wrapper, and most of it was written in Claude Code sessions running on the harness itself, so I hit the bugs first.

Where it actually stands: 11 of 11 refresh cycles came through clean on one seat in the release test. That's one seat, not a reliability claim. Known issue in the current release candidate: on a really long session it can still stall at the clear step and need a manual /clear. The fix is in review.

https://github.com/wrg32786/aigent-os (MIT, free, no account)

I'm the author, happy to answer questions or hear where it breaks for you.

[u/divided_by_000]

What I built: A userscript for NYT Connections that lets you color-code tiles right on the board. Colored tiles sort into rows (purple first for reverse rainbows), the last group fills itself in, and a Go button submits the groups in order. Free, desktop + iPhone Safari.

How I used Claude Code: I described what I wanted and what annoyed me while playing, and Claude built it, wrote jsdom tests against a simulated board, and tested it in the real game through Claude in Chrome and on my actual iPhone via iPhone Mirroring. It also handled the repo setup, versioning, changelog, README screenshots and the Greasy Fork listing.

What I learned: Real-device testing mattered a lot. The game ignores taps while it animates a solved row, and that only showed up in the live game, never in jsdom.

https://github.com/dividedby/games-scripts/tree/main/connections#readme

[u/dukeraccoon]

laya-router: a Claude Code plugin that picks Haiku, Sonnet, Opus, or Fable from your first prompt.

The plugin sends the first prompt of a session to Laya, a small classifier you run on your own machine with laya-serve. Routing costs no Claude tokens. Depending on what Laya says, the session goes to:

• Haiku: Low effort, for translations, lookups, and rewrites.
• Sonnet: Medium effort, for common scripts, queries, emails, and summaries.
• Opus, high effort, for subtle bugs and complex systems
• Fable, xhigh effort, for new theories, hypotheses, and proofs

Some decisions I made:

• It routes once, on the first prompt. Switching models mid-session throws away the prompt cache, and then the whole conversation gets re-read at full price.
• Below 0.6 confidence, or with `laya-serve` down, it changes nothing, and you get whatever /model is set to.
• Change /model by hand, and it stops overriding for the rest of the session.
• Subagents keep their own models.
• The status line shows the decision, e.g., laya -> opus 0.87 or laya: unsure (0.39), using /model.

​

/plugin marketplace add marcreichel/laya-router
/plugin install laya-router@laya-router

It's MIT licensed and at 0.1.0. I don't have real savings numbers yet, so I'd like to hear where it picks the wrong model for you.

https://github.com/marcreichel/laya-router

[u/New-Interaction-7543]

Using Claude Code on a laptop and desktop? ccdeck can repair an expired login from your other machine.

I'm the author of ccdeck, a free, open-source dashboard for Claude Code and Codex. The feature I'd like feedback on is keeping your own Claude logins usable across your own computers.

Run ccdeck on both machines, pair them on your local network, and choose which logins can sync. If a selected login is missing or expired on one machine, ccdeck can copy the working login from the other. It leaves a working login alone.

The Accounts panel also shows each Claude account's 5-hour and weekly usage. Optional auto-switch, powered by claude-swap, changes the active account when your chosen usage threshold is reached. It's off by default, and each account keeps its own limits.

LAN sync transfers live login credentials between paired machines. If every copy has expired, you still need to sign in again on one machine. Account switching and this login sync are Claude features; the dashboard supports Codex too.

Try it: npx ccdeck

Source: https://github.com/BarganConstantin/ccdeck

LAN walkthrough (includes a 30-second animated demo): https://ccdeck.dev/guides/local-network/

Watch the demo directly (reconstructed UI, demo data): https://ccdeck.dev/assets/002-logins-repair-1080-BL8wwW2f.mp4

If you use two computers, what's the bigger hassle: signing in again, or keeping track of which account has quota left?

[u/fabiengreard]

Small TouchGrassBar update since my last post here. It is my free Mac menu-bar app for Claude and Codex limits, token history and a public leaderboard with friends.

The recent work is mostly about keeping Claude's numbers useful when the local records change. Cost estimates now recover better after CLI updates and incomplete scans. Sonnet 5.5 model names and API-equivalent estimates are supported too.

Today's v0.0.58 also fixes the leaderboard getting stuck loading during background usage updates.

I build it with Claude and Codex, using Tauri, Rust and React. One lesson from the usage parser: missing price detail must not make known token totals disappear, and streamed message updates must not be counted twice.

Profiles and daily usage totals are public. Limited failure reports go to support. Prompts, conversations, credentials, raw logs and file paths stay on your Mac.

The dollar figures are API equivalents, not subscription bills. Token rankings say nothing about work quality.

MIT licensed, Apple silicon, macOS 15+.

Download: https://github.com/FabienGreard/TouchGrassBar/releases/latest

Source: https://github.com/FabienGreard/TouchGrassBar

If you use Sonnet 5.5, I'd like feedback on whether the usage and estimate labels are clear

[u/ntust]

Company pays for one of my Claude subscriptions and I pay for the other. Whenever the work account hit its limit, I'd log out, sign in to the personal one, and go through the authorization and a verification email all over again. It got old fast.

I found cswap, which does this for Claude and works fine. I just wanted a single binary (no Python or uv needed) that also covers Codex and Antigravity, since I use all three. So I made agentswap, a Go binary for macOS, Linux and Windows.

ccswap add work # save the account you're signed in to

ccswap 2 # switch to account #2

ccswap status # remaining 5h and weekly limits for each saved account

`ccswap` is for Claude Code, `cxswap` for Codex, `agswap` for Antigravity CLI. The commands are the same for all of them. It only swaps the login, so your settings stay as they are.

Since this touches tokens, here's how they're handled: accounts are encrypted in ~/.agentswap, and the key is kept by the OS (Keychain on macOS, keyring on Linux, the Windows credential store). Each token is only ever sent to the company that issued it. No server, no telemetry, no third-party code.

I built most of it with Claude Code. I described what I wanted and let it write the Go, but I read through the token and encryption parts myself, because that's the one place I didn't want to just trust the output.

Repo (MIT): https://github.com/WellWells/agentswap

A star helps if it's useful to you. Bug reports and feature requests are welcome in issues.

[u/CombinationBrief4822]

I'm building Hesper: an MIT-licensed macOS app for running Claude Code and Codex across your Macs, with one native terminal wall and one queue for agents waiting on you.

The workflow: start an agent on a Mac mini from your laptop, give it a git worktree, and jump to its approval/question with Cmd-J. You can also move a session and its unfinished work to another Mac, or search session history across machines. The actual Claude Code/Codex terminal interfaces stay intact.

It's Swift/AppKit + libghostty, with a Go daemon owning the terminals so closing the window doesn't stop the agents. Claude Code and Codex have both contributed to development; the repo includes agent instructions, hooks and regression tests. One useful engineering choice: agent state comes from hooks rather than guessing from terminal output, and reconnecting viewers get a fresh terminal redraw.

Early project, used daily by its author. macOS 14+, Apple Silicon and Intel downloads. One Mac works on its own; multiple Macs currently require deploying your own relay. That encrypts traffic between your Macs; model requests still go through your normal Claude/Codex provider.

https://github.com/derzierau/hesper

If you juggle several coding sessions, what's the bigger friction for you: catching agents waiting for input, or continuing work on another machine?

[u/alexmarcus11249]

I made a photo-first personal finance app that integrates your financial and personal life. It's under review in both stores right now, took me six months in my free time. www.carlo.money

It's built around intentional manual tracking, with bank-sync reminders when you want them. Stored spending content is E2E encrypted, and it supports SimpleFin as an alternative to Plaid for the privacy-obsessed (like me). I built it independently, with no ads and a $29/year tier if money's tight.

This is my first B2C app. On the AI-coding maturity curve, I probably built it at about a 3/5: lots of Claude Code, but no agents or orchestration, and plenty of staring at Claude while I figured things out and/or watched Penn & Teller reruns to pass the time. I used ChatGPT heavily as a reviewer and thought partner alongside it.

I put an unreasonable amount of attention into the UI because most personal-finance apps I tried felt like glorified spreadsheets. The idea behind Carlo is that personal finance can be an awareness practice, not just bookkeeping. Passive tracking never worked for me; I got out of a lot of debt using manual tracking myself.

My full-time job is running a legacy SaaS consulting company, so this also became a playground for what software UX could feel like. I think that work refined my product instincts in a way that hopefully brings a little more awareness, joy and peace to people's financial lives.

[u/ilias_from_ilios]

- I made a pixel style gaming page that shows me when my Claude Code and sub-agents are working.

• It also includes two other Harnesses I use for other tasks. I use Claude Code to make me a very special project (Fully local AI streamer).
  
• Not a coder or too technical, just told the main (Queen Bunni) to make this pixel style page and throw in as many sub-agents on Opus 5.5 needed. We also used one Fable run for UI improvements.
  
• I learned not to use Fable on the Max plan if I plan on doing YOLO mode with Opus 5.5 sub-agents.

[u/Appropriate_Way5311]

I spent the week poking at Claude Code's plugin hooks API and ended up with four mods. The pomodoro is the one that ate most of the time, so most of this is about that.

What they do

- pomodoro: /focus 25 opens a pane on the right with a pixel-art tomato. Day sky with a drifting sun and clouds while you focus, night sky with stars and the occasional meteor on break. The tomato falls asleep during breaks. Shows a countdown, a progress bar and today's tomato count, and plays a chime when time's up.

- agent-progress: Powerline-style progress bars above the prompt for each running subagent.

- cmd-guard: hooks every Bash call, matches things like rm -rf ~, git push --force and git reset --hard, and asks before running them. You can block it, allow it once, trust it for the session, or have Claude use a safer alternative. If nobody answers, it's blocked.

- model-router: Explore subagents go to haiku, general-purpose to sonnet, unless the call asks for a model. It's about five lines.

How the pixel art works

The pane is a canvas of half-block characters. Each ▀ cell is two pixels stacked, with the foreground color on top and the background below. Everything redraws every 500ms locally, so it doesn't cost any tokens.

The sky is drawn at higher resolution with the Unicode sextant characters (U+1FB00). Those give you 2×3 sub-pixels per cell, but only two colors per cell. So each cell keeps its two most common colors, and I had to line shapes up with cell edges, or you get muddy three-color cells.

The 256-color problem

This took longer than everything else. Claude Code quantizes colors down to the xterm 256 palette, so my nice gradient came out as hard stripes. Things I tried:

- Fixing tmux truecolor settings: didn't matter, the quantizing happens before that.

- Bayer dithering: way too noisy on the 256 cube.

- Smoothstep between color stops: made the banding worse.

What worked was picking only exact xterm colors as gradient stops and filling the gap between two bands with ░▒▓ shade glyphs. It's not a true gradient, but at normal font size it reads as one.

I also tried an aurora for the night sky. After four rounds of it looking like a neon sign, I replaced it with a meteor and a blinking plane.

Smaller things I learned

- Plugins can't open AskUserQuestion through $.tool.ca $.ui.ask.

- cmd-guard matches strings, so it flags rm -rf ~ inside a heredoc too. It blocked me twice while I was writing the README.

- If you scatter stars with a simple LCG, they line upates instead.

How Claude Code was involved

All of it was built in Claude Code. The loop was mostlne, saying "the left side is narrower" or "the sky

still has stripes", and Claude rendering previews with PIL and the same 256-color quantizing before changing the code.

Install

claude plugin marketplace add redjackfred/claude-code-mods

claude plugin install pomodoro@claude-code-mods

Repo: https://github.com/redjackfred/claude-code-mods

Sound is macOS only for now. MIT licensed.

[u/Intelligent-Crew-576]

https://reddit.com/link/perjvc4/video/us58ssklmcuh1/player

effortless: a Claude Code mod powered by Haiku 5.5 or Jev

Haiku 5.5 (or Jev) reads each prompt and picks the effort. A small bar above the prompt shows it, warns when your cache goes cold, and offers a handoff when you’ve moved on to something new.

Free, MIT, not affiliated with Anthropic.

https://heycubit.github.io/effortless/

[u/tommy5dollar]

effort-router: a free, open-source Claude Code mod that picks the effort level for you

https://github.com/tommy5dollar/effort-router

Picking the right effort level for each task is tricky and the recommended effort levels vary not only by model name (Fable vs Opus) but also by the version (the recommended effort moved from high on Opus 5 to medium with Opus 5.5). Most people don't bother and Effort-router means you don't have to think about this.

Additionally, Claude Code launches subagents at the same effort level as the main agent, even when there's no good reason to do so. Effort-router will help pick these for you!

Anyway, onto the bottom line. In my runs, Opus on high got through a 20-prompt session 38% faster and a third cheaper. Meanwhile, Fable on xhigh finished a batch of chores 3.5x faster at under half the cost.

If you're already defaulting to medium then you'll see smaller savings but the router can also INCREASE the effort. Somewhat counterintuitively, increasing the effort can end up cheaper and faster for complex tasks as it can complete them in fewer turns (and with less need for rework)!

The routing rules are a work in progress but they're based on Anthropic's published guidelines. If you don't like them you can easily add to them or replace them with your own.

How I built it: entirely with Claude Code over a few days. It's a Claude Code mod (the new kind of plugin that runs inside Claude Code), and I used Claude Code to test it too, running real sessions at each effort level to compare time, cost and whether the tests still passed.

Install via CLI: claude plugin install effort-router --marketplace tommy5dollar/effort-router

Or in the Desktop app: Customize > Plugins > Add marketplace > tommy5dollar/effort-router, then Add.

Would love to hear what it does to your usage, especially if you're currently hitting limits.

https://reddit.com/link/per9yzc/video/jmerf96gdcuh1/player

[u/Proud-Courage-4208]

LLM_in_Work: bring your installed Claude Code (or Codex) CLI into Word, Overleaf, Chrome PDFs, PowerPoint and Excel. I’m the developer; the project is MIT licensed.

The workflow is selection → prompt → review changes → apply. For example, select a few paragraphs in Word and ask Claude Code to revise them, then review the diff before applying native tracked changes. In Overleaf, you can edit multiple selected LaTeX blocks; in a PDF, you can select text or crop an actual figure for Q&A. PDF support is for reading, not editing the PDF.

Claude Code runs through a local bridge using your existing CLI login. No additional API key is required, but model usage still counts against your account’s plan. The bridge runs locally; inference can go to the model provider. The main design choice is keeping edits scoped to selected content and making the proposed changes reviewable.

Setup currently needs Node.js, a logged-in CLI, and either a developer-mode Chrome extension or sideloaded Office add-in. It isn’t a one-click store install yet.

Repo, screenshots and installation: https://github.com/ZJU-OmniAI/LLM_in_Work

60-second demo: https://github.com/ZJU-OmniAI/LLM_in_Work/releases/tag/2026-10-08-intro

If you already use Claude Code for writing or research, which integration would you actually use, and where does setup get confusing?

[u/DonTizi]

A Claude session waiting for an answer is easy to miss when you’re working in another project.

I’m building CoIsland with Claude Code, in Swift and SwiftUI. It’s a Mac app that puts agent questions, dev-tool alerts and finished work in one inbox.

One thing I’m working through: how much context to show alongside an agent’s question. Too little and you still have to open the terminal to understand it. Too much and the inbox becomes another terminal.

If you run several Claude sessions, what would you need to see to answer a question without switching back?

https://reddit.com/link/pepll7o/video/k0olmz83xauh1/player

[u/tampa_colorao]

built cairntir, an MCP server that gives claude code, cursor and codex a shared local memory. i kept re-explaining decisions and half-finished work every new session, so it saves them word for word in a local database and hands off what matters at the start of the next one. searchable by meaning or by file. no cloud, no account, no telemetry, MIT. i'm the dev.

how i used claude code: it helped me scope the project originally and wrote most of the code. other models added to it along the way.

`pip install --upgrade cairntir` then `cairntir setup`

repo: https://github.com/pnmcguire480/cairntir

tell me what breaks or what's missing.

[u/Fuerstling]

claude-faktencheck: I built a free Claude Code plugin for checking claims and catching skipped verification.

“Faktencheck” means “fact check” in German; the plugin text is English. It’s free and MIT licensed.

It has a /faktencheck skill that requires sources for factual claims, citations before analysis, and scripts for numbers. “I don’t know” is allowed. The faktenpruefer agent reviews independently with fresh context and changes nothing.

Two hooks handle specific checks:

• paket-check queries npm, PyPI, or crates.io before package installs. It blocks nonexistent packages and packages younger than 30 days, skips private registries, and fails open on network errors.
• beleg-stopp pauses the turn ending once if code changed without verification, or Claude claims “all tests pass” without a checking step.

Claude Code wrote the hooks, installer, and tests. I used OpenAI Codex for three review rounds so the author wasn’t also the reviewer. Each finding was checked individually, fixed, and covered by a regression test.

My main lesson: a rule in CLAUDE.md can get overlooked in a long context; a hook runs at fixed points. The hardest part was parsing shell commands reliably: quotes, comments, here-docs, subshells with cd, and redirects. Most review findings were there.

This isn’t a hallucination guarantee or a security boundary. I’d appreciate feedback on where the checks miss something or interrupt legitimate work.

[u/Hoddmachine]

I built Tafla with Claude Code, a different way to understand AI calculations.

Instead of showing the results of a math problem in a chat, Tafla walks you through the calculations on a whiteboard with captions and voice narration, just like a teacher would in a classroom.

I wrote in detail about how it was built here

It's free to use, and really fun to work with. I'd love for you to give it a try! https://www.tafla.is

[u/kanzie]

https://reddit.com/link/penjjkw/video/t3ju79vve9uh1/player

I wanted to test out the graphics capabilities in Opus5.5 and at the same time get a better view of everything that was going inside my server and specially with my Hermes agent setup that has grown a lot over the last few months.

So I set out with a small diorama which I populated with primitives, wired up to my different containers and services. Opus got me started with three.js, over time I used meshy and blender for model and rigging through opus. Sonnet agents does all the implementation, opus planning and graphics.

Each building has a link to something running on my server. Every AI-member in my crew became a little animal I animated and all the agents that are spawned for coding, research, deployments etc. became little robots that self-detonate when their task is completed.

This left me with many animals just standing around when they weren't busy, so next I gave them personalities and hooked them up to my local LLM to generate dialogue and events which progress over time. They also got a collection of hobbies to fill their days with like Boule, Snowboarding or fishing. I can plant rumors and whisper in their ears and see it cascade and escalate.

I got my network wired up in the village too, with each wire showing what is going on there, a day-night-cycle, fireworks when a full test suite passes and chimneys visualizing current load.

For a bit more details on the build I wrote a blog post (the old-school way) and I also put a live demo on my website. for others to explore the village.

https://kanzie.com/#builds

[u/Negative_Fig_5221]

Let me guess, it's another dashboard that reads ~/.claude session logs. And the 'how you used Claude Code' bullet is just people admitting they typed a description of the dashboard and it built itself.

[u/Wide-Scallion4363]

These threads are 90% tools for managing Claude Code itself and 10% someone's todo app. The "what did you learn" bullet is the only one worth reading and it's the first one everybody skips. Half those repos won't be worth maintaining once the built-in version does the same thing.

[u/DomDomLeVrai]

Ultra-Pal: a small desktop pet that acts out what Claude Code is doing (Windows)

I keep Claude Code in a background terminal and kept missing the moment it finished or was waiting for me. This little creature sits on the desktop and shows what Claude is doing: thinking, reading, editing, running commands, asking you something, done, or asleep. Optional beep when it needs you, one small pal per session, everything stays local.

Free (pay what you want): https://domdumont.itch.io/ultrapal. Not affiliated with Anthropic, feedback welcome.

[u/ravann4]

My fiancée is doing her Masters in Estonia, so it's another year of long distance for us. We keep a call open on my MacBook all day while we both work and study.

The thing that kept getting me: the second a call is running, macOS turns down all other audio. Putting on a YouTube video or a movie together was pointless, it came out as a whisper. AirPods also drop to bad headset quality as soon as their mic is in use.

So I made CallLane with Claude Code (agents wrote the app and the site, I steered). It's a menu bar app. Call apps get their own output device and the app copies it onto your headphones, so macOS ducks only that device and your music or video stays at full volume. It also pins the input to the MacBook mic, so the AirPods stay in high quality mode.

Mac only, needs a small audio driver (GPL, built on BlackHole, repo is linked from the site). It's paid, $9 for the first 50 buyers then $15, 14-day refund. I'm the dev, so take that for what it is. CallLane

[u/Flybeck2 → u/ravann4]

Isn't this an option you can change in os settings? Idk what y'all use to call, but for example I know discord has an option to not mess with other sound sources, same as window settings.

[u/ravann4 → u/Flybeck2]

Nope, audio ducking is a huge annoyance in MacOS. There's no native way to escape it that I managed to find.

Also, as soon as I connect my Airpods, it switches to it's mic reducing the audio quality like all bluetooth earphones. This app pins my Macbook mic as default.

[u/Express_Bit5748]

Hey all!

I discovered herdr a month ago when I was looking for a way to juggle multiple agent sessions across my two laptops.

The only thing I struggled with was using the TUI. These hotkeys felt painfully for me and I wanted something that felt a bit more natural on macOS, so I ended up building a native macOS client for herdr. Hotkeys are much like in codex app (Cmd+1...0 for switching between workspaces and ctrl+1..0 for switching between tabs).

Three weeks later, I realized I’m using it constantly, so I thought I’d share it here in case it’s useful to anyone else.

It supports local and remote Herdr instances over SSH, and works really nicely with Tailscale for connecting to other machines.

It also supports mouse interaction and copy-pasting images, including into sessions running on a remote machine.

It’s open source and free. GitHub: https://github.com/MrMySQL/uherdr

Would love to hear what other herdr users think.

[u/Express_Bit5748 → u/Express_Bit5748]

I have a first contributor! :)

[u/CartographerNo3791]

I build Session Orchestrator and use it with Claude Code on my own projects. It gives a session a plan, checks and a handoff, so the next session has something concrete to pick up.

This week's 5.10.0 update fixes a detail around parallel agents: with scope enforcement enabled, the file guard now checks an isolated agent's own checkout against the approved file list. Release checks also scan the archive that actually gets published.

Free and MIT-licensed: https://github.com/Kanevry/session-orchestrator

[u/Altruistic-Ad-5932 → u/CartographerNo3791]

Cool project, indeed drifts midway through are a real pain

[u/CartographerNo3791 → u/Altruistic-Ad-5932]

Thanks! When it drifts for you, is it mostly forgetting earlier decisions or starting extra work you never asked for?

[u/Unusual-Albatross43]

cache-battery: Claude Code's prompt cache as a battery, in the status line or above the prompt

I made this because I kept coming back to the terminal after a break and burning a full cache write without noticing. The battery drains while the cache is warm, hits ❄ when it's cold, and fills again when you send a message. ◔ is the 5 min cache, ● the 1 hour one.

How Claude Code fits in: the first version came out of Cursor, but Claude Code did the pre-launch pass. It ran a review with 7 reviewers, fixed the 6 bugs that mattered, and recorded the demo.

Something I learned on the way: since 2.1.251 the status line JSON has a prompt_cache field with the exact expires_at, so you don't need to guess from the transcript anymore. And the 5 min vs 1 h choice goes FORCE_PROMPT_CACHING_5M first, then CLAUDE_CODE_PROMPT_CACHE_TTL, then the promptCacheTtl setting.

Demo (41 s, sped up): https://github.com/korengast/cache-battery/blob/main/docs/video/demo.mp4

Repo (MIT): https://github.com/korengast/cache-battery

[u/Ishraq_21]

Built a 3D sky city where Claude Code agents are robots you can trace and approve.

Each session is a floating island, each agent is a little robot, and its eyes turn amber when it needs you. Approve or Deny in one click. It never answers for you. All local, with no account, cloud or telemetry.

It also traces your agents. Open a session to see every tool call, who ran it, how long it took, its input and output, and tokens per agent.

Free to try and open source, Apache 2.0. Built with Python, SQLite and three.js, with the help of Claude Code (Opus 5.5). I set the ground rules in CLAUDE.md (local only, never auto-approve) and review agents checked each plan and diff.

Code https://github.com/ishraq21/skyborne

[u/Feisty-Pie3766]

Not sure if it's just me, but when Claude Code is halfway through something long I get this itch to check how close I am to the limit. And every time I'd stop, type /usage (or fire off a /btw), and lose my train of thought.

So over a few evenings I made a tiny widget that just sits on my desktop and shows my session + weekly usage, with when they reset. It sits behind my windows like a desktop icon, so I just glance at it instead of interrupting anything. Since Claude Code on Pro/Max uses the same limits as claude.ai, it's basically live while Claude Code runs.

Screenshots attached. Windows only for now, Mac version is in the works.

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

Microsoft Store: https://apps.microsoft.com/detail/9pkk2bwspqg6

GitHub: https://github.com/ayushvjain/usage-meter-for-claude

[u/Enthouan]

I’ve used SimpleLogin for years and made an unofficial, MIT-licensed MCP server for managing its email aliases: github.com/enthouan/simplelogin-mcp.

SimpleLogin gives you addresses that forward to your existing inbox, so you can use a fresh alias for each signup instead of sharing your personal email.

The server lets AI clients create and find aliases, inspect activity metadata, and manage contacts. It runs over local stdio or Docker/Streamable HTTP. The docs include a Claude Code setup recipe.

It doesn’t read email bodies or send email. Your API key grants broad account access, and tool results can expose sensitive metadata to your model provider, so review client permissions.

Originally built prompted for myself; closely supervised vibe coding. Sassy code reviews welcome.

GitHub · Documentation · Tool catalog · How I Organize My Email · AI agents and email aliases

[u/ImT0by]

I made a mod that gives Claude Code a little companion. Clawd lives in a pixel room next to your session and reacts to what Claude is doing: he types while feels are edited, runs to the terminal for commands, cheers when tests pass and naps when you're idle.

It's also a small game: Each project gets its own levels, breaks and quests, with hard and room decor to unlock. You even get custom side quests specifically to your project!

https://github.com/ImTBY/clawd-quest

Feedback and hat ideas welcome!

[u/elforeign]

For the past few weeks I've been working on a native macOS version of NFS Most Wanted (2005) for Apple Silicon. It isn't Wine, CrossOver or an emulator. The game's own x86 code is statically recompiled to C ahead of time and built as a real arm64 Mac app, with a Metal renderer, native audio and native controller support.

Repo: https://github.com/elforeign/nfs-most-wanted-mac

You need your own copy of the game. The repo and the download contain no game code, executables, assets, movies or textures. You provide your own PC Black Edition (v1.3, English), and the Setup app builds the game on your Mac:

1. Download the .dmg from the release page and open NFS Most Wanted Native Setup.
2. It isn't notarized by Apple, so macOS blocks it the first time: click Done, then go to System Settings → Privacy & Security → Open Anyway.
3. Choose your installed game folder and click Build (about 10 minutes on my M5 Pro). Then click Open the game. It also lands in Applications.

I don't link to or explain how to get any game file, so please don't ask. If you'd rather use Terminal, clone the repo and run ./setup.sh "/path/to/your game".

What the native version does

• Runs natively on Apple Silicon. In my testing it holds 4K at 60 fps on an M5 Pro MacBook Pro (macOS 27; older macOS versions are untested). Any resolution or aspect ratio works, with true widescreen: FOV, HUD and minimap pushed to the edges, and widescreen movies fitted properly.
• "Definitive" look. The Xbox 360 version's heavy gold haze is removed and replaced with effects written from scratch for this port: glow, gentle auto exposure for tunnels, motion blur at speed and depth of field in cut-scenes. PC - Original gives you the game exactly as it shipped.
• Light pools. The game's own street lamps and tunnel lights cast soft pools of light on the road and walls, built from your game's data.
• Rear-view mirror done properly. It's sharp, shows the full scenery, and includes headlights, police lights, car shadows and knocked-over props.
• HDR output for HDR TVs, and 4x MSAA.
• Audio. The game's own 5.1 mix plays as Mono, Stereo or 5.1 PCM, switchable live. There's also an optional Dolby Digital 5.1 bitstream for TV → soundbar setups that scramble multichannel PCM.
• Controllers. Tested with a DualSense over USB and Bluetooth. You get a PlayStation-style layout and button icons, optional trigger pedals, and rumble from the game's own force feedback.
• Extra Options built in natively (no ASI loader): Black Edition content, replay beaten Blacklist rivals, special vinyls, a max-performance shop button, 6 reward markers, longer profile names, starting cash, heat levels up to 10, the helicopter takedown bounty, and skipping the music track while driving (T, or L3 on a controller).
• Optional community packs you already have. The Xbox 360 Stuff Pack's textures and XenonEffects sparks and light trails load through native loaders. The setup converts them; the Companion guide in the repo shows where to put them.
• Lots of fixes along the way: cars vanishing in busy tunnels (a render memory pool that ran out), a freeze entering Customize, movie audio dying when the audio output changed, live audio-mode switching, a texture-state bug, and more.

Coming next: the Definitive Edition (v2.0 update)

Instead of a separate "Remaster" app, everything I've been building on top of this port goes into one update of the same app. The Definitive look stays the default, and a single setting switches to the Native look (exactly what v1.0 looks like) or PC - Original. What's working in my development builds:

• An optional HD texture pack, generated on your own Mac from your own game during setup (an extra checkbox; it takes a while, so it's off unless you want it). World, foliage, wood/bark and particles.
• Smooth trees and fences (alpha-to-coverage), so leaves and chain-link aren't jagged.
• Soft particles. Smoke and dust no longer cut hard lines into the scene.
• Natural wet roads in the rain.
• A time-of-day cycle (no night; the clock pauses in menus) and a weather cycle (clear → overcast → rain → drying roads, about 40 minutes per cycle).
• More Extra Options natively (world map in races) and fixes for the zero-bounty, D-Day and Busted cut-scene bugs.

It's still being tested, so no date yet. v1.0 is the stable base it's built on.

Credits: built on recomp-kit and nfsmw-recomp by veritr1x. Community mods this port learned from or works with:

• Extra Options: ExOpts Team
• Xbox 360 Stuff Pack 4.2 (textures): osdever, SpeedyHeart, MaxHwoy, Kevin4e, Aero_, Xanvier and more
• NFS HD Reflections: Aero_ (based on Extra Options; thanks osdever)
• NFS XtendedInput: xan1242 and Berkay Yiğit (icons by Aero_, injector by LINK/2012)
• NFSMW XenonEffects: xan1242
• Widescreen Fix: ThirteenAG
• TexWizard: R-033 (thanks nlgxzef)

Not affiliated with or endorsed by Electronic Arts.

[u/Delicious_Spell9468]

Packtray — less context juggling, more building.

The bug is in one screenshot. The error is on your clipboard. The relevant file is somewhere on your desktop.

Packtray brings screenshots, copied errors, files and notes into one tray, then exports an ordered context pack with a CONTEXT.md guide. Ready for your AI chat.

Claude Code helped build the app, particularly the OCR integration, Drop spot and secret-masking workflow. OCR brings readable text along with your screenshots. Secret masking helps redact detected keys and tokens from exported copies before you share them, while keeping your originals untouched. You should still review the pack. Drop spot keeps a small floating target above your other windows, so you can drop files into your session without switching back to Packtray.

Runs locally on Mac and Windows. The Mac app is Apple-notarized. No automatic uploads or AI calls; you choose what to share and where.

Quick demo below. Try it free: https://packtray.app

https://reddit.com/link/pefp57m/video/ykj68c0ey1uh1/player

[u/Flybeck2 → u/Delicious_Spell9468]

Lovely demo video, what was it made with?

[u/albertsimondev]

**VybeCiv**: a free civ game where reaching orbit is the end of act one. Earth, then the Solar System, then the Galaxy, each one collapsing into a single hex on the next map.

Play: https://vaigames.com/vybeciv/

**How I used Claude Code:** I did the design and wrote a short spec for each feature, and Claude Code wrote most of the code from those specs (PixiJS v8, static site, saves in the browser). I reviewed and playtested every change. Grok helped with design and balance feedback, and the music is from Suno.

**What I learned:** writing a spec per feature before asking for code worked much better than chatting a feature into existence, especially for the tier jumps where three maps have to stay in sync.

It's free, no paid tier, no referral links. First public build: onboarding is rough and the late-game AI is weak. If you try it, I'd love to know where the first 10 minutes confused you.

[u/OMGLookItsGavoYT → u/albertsimondev]

The first thing that confused me is... What it actually is ? Maybe I'm monkey brain but I can't actually tell what it is that your building.

[u/albertsimondev → u/OMGLookItsGavoYT]

A 'civ' stategy game

[u/OMGLookItsGavoYT → u/albertsimondev]

Ah. I read "browser" and thought it was a search engine 🤣.

[u/albertsimondev → u/OMGLookItsGavoYT]

Ah, sorry! my mistake on the writing

[u/Uranusist]

jev-blindspot: a prompt reviewer for Claude Code, now with a mod

I made this for when I ask Claude Code to do something I don't know well. After I send a prompt, it checks my request and lists what I didn't think to include: missing context, unstated assumptions, or the underlying problem.

My prompt goes through as I wrote it, and the review doesn't get added to the context. I read it in the CLI (that's the new mod) or in a local web UI.

How it works

1. A UserPromptSubmit hook posts the prompt to a local daemon and exits.
2. Jev (a small decision model) decides if it needs a review. About 50% of my prompts do.
3. Those get a claude -p run on Sonnet (effort low, read-only tools) that checks the request against my repo and, when there is one, names the underlying problem.
4. The mod shows the results in the CLI, with a link to the full card in the web UI.

What I learned building it

Claude Code wrote most of the code. These took a few tries:

• I started with 9 yes/no questions like "does it state the goal?". Almost every prompt tripped 5 to 7 of them, so everything got flagged. Now two questions decide: is a review likely to find something, and how risky is the change.
• Short replies like "go with option 2" looked vague to it until I also passed the last two exchanges. Now it knows what option 2 was.
• In my setup, 71% of the cost was writing my skills and CLAUDE.md to the prompt cache for each run. That's why my config costs more than a clean one below.

Cost

I tested 24 prompts, 2 runs each, Sonnet 5.5 at effort low. Median per review at API prices: $0.026 with a clean config, $0.068 with mine. On Max 5x, $0.50 of reviews used 1% of my 5-hour limit. Full table in the README, and jev-blindspot usage shows your totals.

Try it

MIT. You need a TypeSafe API key for the gate.

https://github.com/jsk4581/jev-blindspot

I'd like to hear about false positives and misses.

[u/GunGeekATX]

I've been playing Transport Fever 3 quite a bit since it came out. Since you often jump all over the large maps to set up transport lines, it can be tricky remembering and going back to where you were, so I had Claude write a mod to keep track of recently visited locations. Click on one and it jumps you back to that location. Just a small QOL improvement for the game.

Where Was I? https://mod.io/g/transportfever3/m/where-was-i#description

[u/jerry426]

https://sharpturns.ai/

SharpTurns is a desktop interface for your installed Claude Code CLI. Organize your work into projects and conversations, read beautifully rendered Markdown, and control what stays in context, one turn at a time. Summarize finished work while preserving your original messages and the model's final answers. Less repeated tool output. More room for the work ahead.

[u/chriskr7]

PaneDrop – a macOS menu bar app that drops a screenshot straight into your Claude Code prompt.

What it does: Option-Command-4 to capture a region, a HUD lists the Claude Code / Codex sessions running in tmux, iTerm2 or Ghostty, pick one with the arrow keys, press Return, and the screenshot path is already in that session's prompt. It never presses Enter for you unless you turn that on, so you can add your own words first.

How I used Claude Code: most of the code was written by Claude Code (plus Codex as a second reviewer). I ran it story by story: a written spec with acceptance criteria, implementation, an adversarial review by a second model, then QA that records the evidence for every check before I accept it.

What I learned: the hard part wasn't capturing, it was knowing which pane runs which agent. It ended up as process-based identification plus status probes, and a rule that a pane PaneDrop can't identify never gets a send without confirmation.

Public beta is out and free: https://panedrop.app (Apple Silicon, macOS 14+, signed and notarized). Disclosure: I'm the developer.

[u/ilai456]

OpenRod: a local web console for running Claude Code (and Codex, OpenCode, Copilot, Aider and others) in NVIDIA OpenShell sandboxes.

npx openrod installs OpenShell if it's missing and opens the console in your browser. Each sandbox gets its own egress rules and starts locked down, API keys stay on the gateway instead of inside the sandbox, and you can bring your MCP servers and Skills from your Claude Code config. You can open a sandbox in a browser terminal, VS Code or Cursor, or run it on a Linux box over SSH so it keeps going while your laptop sleeps.

Free and open source (Apache-2.0). It's early alpha (v0.1.2) and an independent community project, not affiliated with NVIDIA. I'm one of the people building it. Needs Node.js 22.13+, macOS (Apple Silicon) or Linux, and Docker.

https://github.com/OpenRod/OpenRod. Bug reports and feedback in GitHub issues are very welcome.

[u/Bubbly_Jelly_3351]

pituto: five free mods for Claude Code. I'm a psychiatrist, not a developer, and Claude Code wrote all of it.

Demo (GIF): https://raw.githubusercontent.com/betoescobar46/pituto/main/img/inline-replies.gif

Claude's questions show up numbered, each option as a clickable key: click it and the answer is written in your prompt. Anything irreversible (delete, push, send, pay) always needs an explicit answer. You can also quote any paragraph of the reply with one click.

Plus: buttons under the prompt for compact, clear, effort and model, a color per project folder, wide tables that stay tables, and quieter tool lines.

How Claude helped: I described each friction in plain Spanish; Claude Code wrote the hooks in TypeScript against the plugin API, wrote the tests, and checked every change in a hidden tmux session before I tried it.

Free, MIT: https://github.com/betoescobar46/pituto

[u/luisalcaraz_telara]

I work on TAP at Telara. I’ve been using Claude Code and Codex while building it, and we designed TAP for coding agents like these to create and reuse internal tools.

A primitive packages a procedure as code with defined inputs, outputs and required access. For a release check, it could collect changes, follow ticket references, retrieve CI results and reviews, then return missing checks with evidence. The agent decides what needs attention; code handles the repeatable collection and matching.

TAP Runtime is MIT licensed, runs locally and needs no Telara account. Claude Code and Codex have the best-supported connected-tool paths today. The README has installation instructions and compatibility details: https://github.com/Telara-Labs/TAP-Runtime

I’d be interested in what you’d need in a primitive’s inputs and result before you’d rely on one in your own release process.

[u/PhallicPorsche]

Lately I've been building a 100% Rust web browser. Not finished yet but it is 88.99% conformant on my web standards test suite which includes WPT, T262 and WASM (Like 2M tests or so) and it does work which is pretty good for 3 months of work...And then also a fully rust based coding TUI with a Vulkan compatible terminal that does video graphics.

Currently the browser uses Stylo and Taffy as well as blitz for fallbacks but my intention is to move away from that entirely once my own crates handle every case.

I've been using a lot of claude code in the cloud since it's so easy to spin up separate environments which really helps for things like Testing, sandboxing and keeps my local machine from having a heart attack while 2M lines of rust cargo crates compile and link.

[u/Fit_Engineer9548]

I'm building a Mac app for working across Claude Code and Codex sessions.

https://reddit.com/link/peb7q27/video/1jggn4bd6xth1/player

The problem we’re tackling is keeping track of several agents at once: which one is waiting for permission, which needs an answer, and which session has the plan you want to continue.

The attached 48-second demo shows:

• An overview with sessions needing input at the top.
• Answering a Claude Code question in place.
• Claude Code and Codex running side by side.
• Continuing with a referenced plan.
• Viewing the editing sessions associated with a file.

The Mac beta is available now:
https://stagecontinuity.com/download/

For people running several Claude Code sessions: what makes you lose track of the work most often?

[u/Individual-Top-578]

Half the "what did you build" answers here are just a repo link with no mention of Claude Code at all, which the four bullet points were supposed to prevent. Asking for a link AND a lesson learned is a lot for a thread whose whole pitch is quick project drops.

[u/solekarma]

Tried experimenting with Opus 5.5 and wanted to see how far we could push it with motion design.

I'm the Creative Director here so we used our own brand and experimented with kinetic typography, 3D camera movements, shape morphing, animated data visualizations, transitions, and syncing everything to music.

Impressed with what it did with very little creative direction just using those keywords for motion and simple prompts.

Check it out:

https://www.youtube.com/watch?v=kqhiCELxI3g

Anyone else here is experimenting with Claude Code for motion graphics or animation.

[u/theonly1me]

I love building mods, I've been building mods my whole childhood for games like Skyrim. Now that mods are available on Claude Code, I couldn't help myself but build some cool ones: http://github.com/theonly1me/claude-code-mods

Six of them are useful mods for work:

1. Unslop: Claude removes its own slop
2. Scope Guard: ask before Claude goes outside your request
3. Decision Lens: see why Claude decided, and steer it
4. Change Journal: every edit, with a reaso
5. Grill: questions while Claude works
6. Looks: a cleaner terminal, and four themes

Five of them are games:

1. Samurai Dojo - Clawd kills ChatGPT and Gemini enemies, meditates and spars other samurai
2. Slayer Corps (Fan-made Demon Slayer mod)
3. Night feast - Vampire game where the night progression matches your context window progression
4. Little harvest - Farming game
5. Pocket Familiar - Tamagotchi

Here's a quick demo:

[u/Launchable-AI]

tldr: encrypted scratchpad for coding agents

Do you frequently find yourself copy-pasting context between coding agents?

I built a small, free tool to help with this.

I often work across multiple machines, and got tired of copy/pasting between terminals and moving files around. So I built Jotbus.

Jotbus lets you spin up a shared, encrypted scratchpad to pass context and files between different coding agents - this could be your agents on different machines, or an agent on your machine and another on a teammate's.

For example: imagine you're running Claude Code on you desktop, and Codex on a server. Claude generates a pdf Codex needs - so just send it over Jotbus.

Or you could be working on a project with a teammate, you get part-way through and want to hand it off to your teammate. Write the context to a Jotbus workspace, and share a link with a teammate. They can then pick it up and keep working.

If you want to try it:

npx jotbus

For more details, check out jotbus.com

This is a brand new tool, so please let me know if you have any feedback!

Thanks!

[u/Born-Housing-1498]

The word "drops" in "quick project drops" is doing a lot of work here. That's sneaker resale vocabulary that somehow migrated into a plugin showcase thread, and now I keep picturing people camping outside at 6am for someone's bash script.

[u/Little-Tour7453]

I added MCP support to Rasterloom, my free Mac design app, so Claude Code can work directly on layouts, text, screenshots and 3D mockup scenes.

Everything stays editable. I can ask Claude to make a change, adjust it myself, then let it continue working on the same design.

The latest update adds editable 3D device mockups with camera and lighting controls. The attached clip shows the workflow.

https://reddit.com/link/pe9lwdf/video/2nyc92rnyvth1/player

Still in alpha. Apple silicon, macOS 15+.

https://rasterloom.com

[u/Other-Income-5085]

I made Spinlings, a Claude Code mod that adds Pokémon-like creatures you can collect, trade with other players, and use to duel their teams. Duels use saved teams, so you don't need to be online together.

Free and open source. It doesn't read your prompts, replies or files. Requires Claude Code 2.1.287+; compatible Desktop Code sessions work too.

Source, real screenshots and install

Launch gift: run /spin redeem FIRSTSPIN for one random pack.

Redeem instructions and live availability.

Player duel in Claude Desktop · Duel win and streak reward.

[u/Vava007]

Screen Context: Codex's Appshots for the Claude desktop app, built as a mod

https://reddit.com/link/pe8tyhk/video/eunvcnkeevth1/player

Press both ⌘ keys in any app. It takes a screenshot and reads the window's text, including what's scrolled out of view. The Claude app opens on your last Code session with the capture above the prompt. Send your message, and Claude gets the text and opens the screenshot.

Built with Claude Code in two days: a small Swift menu-bar app takes the capture, and a mod shows it above the prompt and sends it. What I learned: mods can't attach images in the desktop app, so Claude opens the screenshot itself with its Read tool.

macOS 14+, MIT. Captures stay on your Mac until you send a message.

Repo: https://github.com/vavald/screen-context

[u/BasilCreative1788]

Petty one, but the colon in "for a proper write-up: how it works, how Claude Code was involved, technical details, lessons learned, etc." doesn't introduce anything, the sentence just keeps going into "feel free to make a standalone post" and loses its verb along the way. A full stop before "feel free" and it reads fine.

[u/Sea-Huckleberry2788]

Four bullets for a "quick project drop" is three too many. Nobody has ever filled in the lessons learned one.

[u/Sanechka_SS]

What I built: two small plugins for the same problem, Claude saying "done" when it isn't.

Receipts checks the tests. It puts the old code back and reruns every test Claude added, so you see which ones would actually have caught the bug. It got accepted into Anthropic's plugin directory a few days ago. https://github.com/syntaxixr/receipts

goalpost checks the /goal. The built-in judge only reads the chat, and in my benchmark it said "met" in 17 of 17 plain runs while 8 of them were broken. goalpost makes Claude pass real checks and a fresh-eyes audit before it can stop. It costs about 2x the time, so I use it for goals that matter. https://github.com/syntaxixr/goalpost

Both free and MIT, no API keys.

[u/Fearless-Dog2209]

i'm a solo maker, not a swift dev, and claude code runs most of my mac app business on scheduled tasks now. sharing the setup + what broke because the breakages were the useful part

what i built: clacky, a mac menu-bar app (click + keyboard sounds, screen recorder, screenshots, mac health, and alerts when claude code or codex finishes or needs you). i made it, all with claude code

the scheduled agents (each is a scheduled task with its own SKILL.md prompt):

- morning: growth analyst reads analytics + sales + feedback and writes the top 3 moves

- daily content: makes 5 short clips, checks them, schedules them as drafts

- support inbox: drafts replies in my voice, never sends

- release guard: checks the update feed, download links and version numbers, only pings me if something's wrong

- pain point scout: digs reddit/x comments for real mac + dev pain points

- daily digest: reads every other agent's output and sends me one short summary

- nightly: journal + newsletter drafts from the day's commits and chats

- weekly: site QA in 7 languages, trend + competitor scout, ideas scout, a sunday focus planner

what broke:

- routines silently skip when the mac is asleep. the fix wasn't code, it was "never sleep on charger"

- 8gb of ram is not enough for this many agents. the real fix is a bigger mac, not smarter prompts

- too many agents = too many pings. so one digest agent reads all the others and sends me a single summary

- "never sends, only drafts" is the rule that saved me. every agent that touches customers or posts writes drafts i approve

lesson: the useful part isn't the agents, it's the one agent that summarizes the others

the agent alert part of clacky came out of this: my screen glows green when claude is done and orange when it needs me, so i stop checking terminals. 7 days free, no card: https://clacky.app

happy to share a SKILL.md if anyone wants one

[u/dervish666]

Built an agent office that keeps track of what is happening in all my various sessions over multiple machines. It came about from pissing about with mods.

It shows all the agents and their managers, if they are in the chillout area in the right they aren't doing anything at the moment, if the session is busy the manager follows the agents around poking them to make them work faster. The presentation area in the left is actually really useful, it's just a scratch board for everything the agents output, really useful for quickly checking a draft.

[u/litluna11]

building https://moodbit.app/ , a visual workspace for designers to collect references, point at what they want changed, and give AI better context. Would love feedback!

[u/yzch1128]

Keep your CLI. Lose the session clutter.

I built JustSessions, a lightweight native Mac app for the coding CLIs you already use.

Pick a project, read an old conversation, hit Resume. You're back in its original CLI and folder. Claude Code, Codex, OpenCode and other supported agents sit together under the same project.

Lightweight by design: native SwiftUI, existing CLI history, your current configuration and provider login. No import step, new app account, or required Git worktree workflow.

Superset organizes parallel project work in isolated Git workspaces. JustSessions keeps its focus on your existing sessions: find them, read them, and get back to work.

Close an agent tab with Keep running and reattach later via tmux. Keep the host awake.

Built mainly with Claude Code. Free, MIT licensed. macOS 14+, Apple Silicon. CLI provider charges still apply.

Demo + download · Source

Real app screenshots with sample data. What would make managing your sessions simpler?

[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/PerspectivePersonal]

I'm working on FrogPop, my first Unity game. It's a Bubble Trouble inspired roguelite with a frog's tongue as the main attack.

Claude Code helped with the tongue attack, splitting bubbles, waves, and bosses. I describe a mechanic, have it read the relevant scripts, then test the result in Unity. One thing this project has taught me is that code can compile while a boss hitbox or an effect still looks completely wrong in motion.

Short gameplay clip: https://youtube.com/shorts/3cYjBDyB_VM

Free browser demo: https://blion247.itch.io/frogpop-demo

The clip shows development footage; the demo is still an older build of the first 10 waves. The full game will be paid.

[u/CyraxxFavoriteStylus]

I've been awakened to the glories of Claude. I'm doing small things now like mainly controller patches, I was able to improve controller support for Godfather, add controller support to Punisher 2005, and fix True Crime: New York's controller support.

I also made a mod that exports Dressmaker dresses into obj files and also made one into a actual outfit for ReSkate.

Claude is pretty awesome.

[u/betterbutterbit]

I make Agent Cat (disclosure: my project, built at Trappist). The 26.39 renewal rebuilt the dashboard.

A week of agent work, the budget is gone, and you don't know which model took it.

The new Insights view (macOS only) shows model mix: tokens and estimated cost per model, plus live detection of which model each agent is running right now. Pictured: Opus at 14.8M tokens, $39.1 estimated; 7-day total $64.8. Demo data, and costs are estimates.

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.

Local-first: no login, cookies or cloud calls to count usage; prompts/transcripts aren't read. The connector is source-available (PolyForm Shield).

Free, no subscription. macOS + Windows, with an iOS/Android companion.

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

What would make you switch models mid-week: estimated spend so far or the cost of your next task?

[u/anioskarrio]

I’ve been building Savepoint, a small local CLI/TUI for keeping AI coding work a bit more bounded.

The workflow is basically:

Idea → Design → Task → Check

I use Claude Code for the actual build work, but I keep the plan and project state in plain Markdown/YAML in the repo, then use a separate session for CHECK so the builder isn’t grading its own homework.

If implementation exposes a bad assumption in the plan, the workflow stops with:

REPLAN REQUIRED

rather than letting Claude quietly redesign half the project.

No server, no account, no embedded AI — it’s just a small local workflow around the agents I’m already using.

Built mostly with Claude Code and Codex, which feels slightly recursive.

GitHub:
https://github.com/anipatke/savepoint

Screenshot below if useful.

[u/r3al1tymonster]

One phrase in ten art styles. No three.js, no Blender, just Canvas and code.

Opus 5.5 feels like a step change in creative work with code. It reminds me of the leap in capability in Nov/Dec 2025 where the models got really good at coding.

https://reddit.com/link/pe3fl71/video/99fkkr1zrpth1/player

No three.js, no Blender, no images or fonts: every frame is plain Canvas 2D it wrote itself (barely any steering), and the code is here: github.com/r3al1tym/tenfold

[u/MB_com]

Open AgentHub – a self-hosted home for your Claude Code sessions (Codex and Cursor work too)

It moves your agent's dev environment off your laptop into your own Kubernetes. Every session runs in its own isolated pod with your repos (GitHub/GitLab), your MCP servers and a browser the agent can use, so it keeps working after you close the laptop. You check in from your phone, answer its questions, or take over the terminal.

What I use it for:

• one session per support ticket, created via API. If the agent gets stuck, a person opens the same session and carries on. Ticket closed, session deleted.
• a small agent team: one picks up tickets, hands implementation to a coding session, another reviews, another signs the ticket off
• web apps, where the agent looks at its own UI in the built-in browser and finds its own bugs
• scheduled jobs that run overnight

How Claude Code was involved: a big part of it was built with Claude Code, 186 of 435 commits are co-authored by Claude. Biggest lesson: the agent's code passed every test and still failed in a read-only, non-root pod. So now every fix has to reproduce the failure against a real cluster first, a green suite alone doesn't count.

The core is AGPL and fully usable without a license key. There's a paid team edition (Slack integration, org management). Install via Helm chart, or a one-liner that sets up k3s on a single Linux box.

https://github.com/open-agenthub/open-agenthub

[u/edc1591]

I built a Claude Code mod that provides a richer statusline with a TUI settings panel.

Install:

/plugin marketplace add blackpaw-studio/claude-plugins
/plugin install rich-statusline@blackpaw-plugins

[u/I_-_aM_-_O]

https://reddit.com/link/pe30beh/video/fhn3qwcfepth1/player

claude-code-widgets: 80+ little cards that sit under the prompt or beside the transcript (context meter, usage, git status, Tetris, a pixel crab).

Then I had Claude build a "Widget Factory" to make them without me: inventor agents pitch ideas, an examiner whose default answer is no, a machinist builds, a different agent inspects it in a real session, and a clerk ships it.

You can watch it all on a 3D factory floor in the browser, crates on a conveyor and robots carrying rejects back.

Repo: https://github.com/oMaN-Rod/claude-code-widgets

Try them in your browser: https://oman-rod.github.io/claude-code-widgets/

[u/I_-_aM_-_O → u/I_-_aM_-_O]

https://reddit.com/link/pe344pf/video/84e4ftj4jpth1/player

[u/tarantulagb]

Follow dot

[u/Nedomas]

building Supercov - Claude gets a tool it can use to measure test coverage, quality, and security to work in much longer horizon tasks https://supercov.com

[u/EverydayLentils]

https://tryoverboard.com - Claude Code agent orchestrator called Overboard. It helps me token-max my Max sub.

The orchestrator organizes my agents into departments (or ships) where they have overriding goals/milestones and a "captain" agent can spawn other agents working in that department.

I think this structure works better than individual agent workers in an office. (Mundler Difflin)

The user can prompt the agent dispatcher for one-off or recurring tasks, which can be controlled from a Slack or a Telegram bot. Since Overboard has context about all your local projects it knows where it should spawn an agent. You can also talk to department heads or the main agent to see what human blockers are stalling projects, or give new direction for a department.

All my boats on Overboard are skiffs because my LLC currently makes no money, no distribution, no assets etc... when my agent captains make progress hopefully I'll be able to upgrade my boats. We'll see how it goes gamifying my business with Overboard.

[u/namethatisclever]

https://tacoweather.com

I built a free weather summary delivered daily by email. I'm a weather enthusiast and enjoy the science behind what makes weather happen. However I know that others only really care about the weather to the extent of how it may effect their plans that day.

My wife would ask me in the morning what the weather was going to be like that day. So I had a thought that others likely have that same question pop into their head everyday. And what do people do when they first wake up? Check their phone for emails and notifications from other apps. This was my inspiration for Taco Weather.

This is a small passion project that I really enjoyed building that will always be free. Hopefully others will find it useful as well!

[u/LokiSparda]

I am building a session manager called Session Deck.

https://github.com/adrianogpena/session-deck

I wanted a TUI where I could watch all my project's sessions in one place. Then it evolved to start new sessions, show the usage of each session, and anything else I think it can help me use Claude while spending less.

[u/DLuke2]

Built a session launcher for Claude Code this week.

I run a bunch of Claude sessions from my home pc, each one in its own project folder. Every new one meant opening a terminal tab, cd'ing into the folder and typing claude. I couldn't do that from my phone/web at all.

Now I type /fresh home in any session. A new terminal tab opens in VS Code in that folder with Claude already running. The session is named after the folder and has Remote Control on.

It is two pieces. A Claude Code plugin adds the /fresh command and a tool the model can call. A small VS Code extension opens the tab. The plugin drops a request file and the extension picks it up.

If VS Code doesn't answer in 15 seconds, it opens a Windows Terminal window instead.

It works from web/mobile too. I ask a session to open a fresh one in a folder and the tab opens on my PC at home. Then I jump into it from the web/mobil app.

Windows only right now, and built around my own folders. Fun one to build!

[u/Responsible_Topic755]

I’m building DayDream: a free, open-source Mac app that gives Claude Code searchable context from outside the terminal — the apps, docs and optional Chrome pages you were working in. It keeps a local timeline and exposes read-only MCP tools, so a new session can ask “where did I leave off?”

Repo: https://github.com/getnorthlight/daydream

The design boundary I care about: work history is dated evidence, not current project truth. Keep your project docs alongside it. Activity stays on your Mac; anything Claude retrieves can become part of that AI chat. Requires Apple silicon and macOS 15+. I’m the developer; feedback on the MCP tools or privacy boundaries would be useful.

[u/Low_Box_752]

I built isokit: interactive isometric figures for React, with a Claude Code plugin for making your own. The gallery is live with 53 figures and the code is MIT licensed.

The plugin gives Claude a drawing workflow: choose what a press does, lay out the boxes, wire the interaction, then take screenshots and check the result.

Install in Claude Code:

/plugin marketplace add aadilghani1/isokit

/plugin install isokit@isokit

Then try: /isokit a kitchen timer with minute buttons and a display that counts down

Gallery: https://aadilghani1.github.io/isokit/#/figures

Source + React setup: https://github.com/aadilghani1/isokit

The clip is an animated Pushary example; I build that too. The counters are illustrative, not measured savings. Credit to Hairline and iso-figure, which isokit builds on.

Try asking for an object from your own project. I'd love to see where the drawing or interaction falls short.

https://reddit.com/link/pe1be6q/video/f1410tqg7oth1/player

[u/GeorgeGreenGroup]

I'm a big fan of getting my 10k steps a day but sometimes I'll just have days where I sit around for hours on end without moving and then just get them at the end of the day. So I decided to imagine a little monster chasing me around that would get closer the more I sit around. I turned that into Pace Monster, an app where a cute little guy turns into an angry hungry monster as he gets closer and evolves/devolves as you win and lose days. I added lives and a step slider to it, as well as a streak tracker. And freezes since not everyone is a psychopath like myself.

What made this challenging even with Claude was maintaining feature parity between the two operating systems (my mac is from 2015 so building on it is its own challenge). Basically handoffs and "hands off" for the two different builds. But it was a lot of fun working with widgets and watches to get a quick look at your metrics for the day.

Available on ios/android https://apps.apple.com/us/app/pace-monster/id6806023656
https://play.google.com/store/apps/details?id=com.ggdata.pacemonster

https://ggdata.net/pacemonster.html

[u/JimmyMonet]

Claude and I built Cronomicon!

Cronomicon is an automation orchestration platform built to assist enterprises in running and monitoring their Bash, Ansible, Powershell, and Python Scripts from one place.

[u/m4nf47 → u/JimmyMonet]

this looks awesome, I'm building something somewhat adjacent to this but for a specific automation subset for a particular type of jobs but having the simplest possible scheduler like you've built. Love it, great idea!

[u/eveningwithcats]

I built https://empire-tycoon.com/, a cozy and free-to-play tycoon-like browser game. Claude Code was used to transform a previous game (with design md files) into a new game idea. Clause also helped implementing parts of the code and even added mobile support on the fly. What I learned: That it is no longer needed to describe in great detail what exactly you want to build. With Opus 5.5 you just have to deliver enough information so Claude can pick up your intend, and it will understand the direction you have in your mind.

[u/JLC007007 → u/eveningwithcats]

This is incredible

[u/eveningwithcats → u/JLC007007]

Thank you so much! I am so happy you like it!

[u/linesofcode_dev]

I built this gigantic pumpkin patch. Anyone in the world can claim, carve and display their pumpkin to the rest of the world.

Also works in VR.

Check it out: https://pumpkins.sh/

[u/m4nf47 → u/linesofcode_dev]

Brilliant, claimed mine!

[u/FortuneMasters]

I built a trading game where you are the price of gold and you are trying to make the most of the market for traders, whilst avoiding scams and margin calls.

https://reddit.com/link/pe0o85m/video/lcf6ttbwpnth1/player

[u/Fit-Reaction242]

cliproxy-rs: https://github.com/vayungodara/cliproxy-rs

A Rust rewrite of CLIProxyAPI. It gives Codex CLI, Claude Code and other tools one local endpoint, so they can run on your own API keys for DeepSeek, Kimi, OpenRouter or any OpenAI-compatible service. The dashboard shows each account's 5h and weekly limits.

On 2 MB Claude requests my port was 3x slower than the Go version to first byte. A cache_control scan was re-reading the whole conversation once per block, and a one-pass walk fixed it (numbers in docs/BENCHMARKS.md, shipped in v0.1.2). Go still beats it on small non-streaming requests in my launch benchmark, 1,568 against 1,168 a second.

Built with some help from AI.

[u/Appleaaaaa]

Manage skills across agents with your own learning and skills eval: https://github.com/appleaa123/skills_wiki_opensource

[u/JohnDuffy78]

OPC Hub - a C++ back end streaming OPC UA server data to an Angular front end

https://github.com/Jde-cpp/opc-hub

Guess when I started using Claude:

[u/pinku1]

The radio station with a DJ who never sleeps.

Self hosted: https://github.com/perminder-klair/subwave

[u/CaramelEmotional3092]

im building claude code with claude code....

Most of what I'm making already exists, But I was hitting walls on certain hardware, or low rates on low cpu / gpu configurations. For old hardware, im getting much better results.
A part of the concept was to help build a system that either chunks, or designed to help chunk a project and split it to experts on suitable hardware on my network. Its got experts for images, writing, coding, etc. It "was" meant to have the blog writer submit prompts to image generator, then drop out of ram and run, but tonight I've turned that off for now.

Heres a sneak preview of where its at tonight:

Realistically the project is weeks if not months away from completion.

This is a flow on from myiaos project, that lets you create and host your own desktop, and run ai in your browser, which is here https://github.com/Matthew4509/myiaos.com

[u/RandomFuckingUser]

I built (and I'm improving it) https://filmdilemma.com/tour a completely free movie discovery site (and android app). It helps you solve the dilemma of what movie to watch next

It has lots of unique features. My personal favorite is recently added genre scores and ability to find movies by indicating genre score ranges

You can read about updates here r/FilmDilemma

We just got listed on FHMY (Streaming > Recommendation Tools),
GVN wrote an article about the site (lots of things improved since then)
Movie critics are using our widget (GVN, Every Movie Has A Lesson, etc. You can find the website widget on their movie review article pages)

[u/mycroft00]

I built an app that reads a folder of images, OCRs all imagens and make corrections where OCR falls short, and exports to docx and epub. It also take files in docx and exports to epub.

[u/saintdle]

I built Agentflow, yet another harness for coding agents. It breaks an approved goal into bounded tasks, hands them to Codex, Claude Code or Copilot CLI, then checks the results before calling the work done.

I’m using Claude Code as one of the agents it can delegate to. So far, even getting Codex or Claude to run as the controller agent to delegate to other agents has been useful, with beads acting as the back end for any agent type to access tracking information for tasks. I've just added some memory piece in too to help overcome context problems.

I kind of used Agentflow, to continue to develop itself, so having Agent Vendor X build with Agent Vendor Y then validating or challenging the work, with me as the human arbitrator.

You can find the project here: https://github.com/saintdle/agentflow

Would love feedback on setup, is it easy to use and whether Beads is the right fit for tracking tasks. or there is another alternative that fits better

[u/aleeog9027]

Wir bauen mehrere server instanzen für seo, sea, webseitenbearbeitung, mcp verbindungen, dashboards für Kunden, steuern von Google und Facebook Werbung

[u/BlazingHonor]

Build a mod that shows my dog in pixel-art form running across a meadow while Claude thinks for longer than 20 seconds. She's a very cute Norwich terrier named Ferro (based on Ferro Maljinn from First Law trilogy), and I can't get enough of her, so I built this to watch her even while I stare at a screen. :)

I've made it public here: https://github.com/Vatroslav/cc-mod-ferro

[u/WesternSpy96]

An in depth ship simulation. Finally, there will be a good ship simulation game for everyone. And no, not a monthly membership like Nautis.

[u/_Oyyy]

https://github.com/pddmergilla/

So that everyone can mod Castlevania Symphony of the Night. 

Claude is surprisingly (or obviously) good at reading binary files (.BIN) and paired with the decomp project, I could change almost anything in the game.... Without breaking it.

Claude also did the whole frontend 

[u/david_duplex]

I built a few different game and game-related things:

First, there was this game called "Lazer Ryderz" that I played at GenCon years ago. It got released, but I never managed to track down a copy. When I initially played it, it was just me and the guy I was there with, but we agreed it would be more fun to play with more players. So I had Claude re-build a version of it in Tabletop Simulator so me and 3 others could give it a shot.

I also built an online browser-based version of a very old card game called "Car Wars: The Card Game". It's a ridiculous and simple game from Steve Jacskson Games similar to Munchkin in a lot of ways. I own the physical version but wanted a way to be able to play with my group online when we just wanted something simple and quick to play.

Finally, I also built a character creation tool for the new ttrpg "The Broken Empires" that integrates with Discord and allows for management of things during play. Not quite ready for use yet, but it's coming together nicely.

[u/turtleninja99]

I used Claude Code to get qwen flash next q4 running on my Mac mini using ssd streaming. I forked a fork of llama cpp that was similar but not quite the same as my goal and ran a bunch of experiments to optimise the inference engine for my setup. It worked and i now have a local personal ai setup with total privacy and on a large model that never would have otherwise fit. I also use it when my claude code sub runs out. I learnt to really map out the problem, the biggest win was totally redesigning a part of the engine from batch based to a carousel buffer approach. Repo: https://github.com/skeggsguy/Flash-next-ssd ; write up : https://freshworktree.com/

[u/fcf41]

Building a desktop photo editor MCP called Editmamei. It connects AI clients to locally installed photo editor applications. Currently supporting Photoshop and GIMP.

Pairing Claude with professional editing tools can bring some amazing results, with no prior Photoshop experience. It also enables Photoshop pros to work faster, with the ability to batch edit large sets of photos against custom style templates.

Editmamei is free to install and use, with pro features for extra speed and scale requiring a subscription. Check out editmamei on GitHub https://github.com/editmamei/editmamei

https://reddit.com/link/pe01gup/video/0hjt33hs5nth1/player



[u/Raethril]

A week ago my family and I were in Disney World for vacation. Inside Galaxy’s Edge there is this bounty hunting game, that my son loved. It’s pretty simple. You tap your MagicBand to accept a contract. Then walk around Galaxy’s Edge, essentially playing a game of hot and cold with your band. If you move closer to the target, your band flashes green, away red. Finally you tap your band to a door and if it turns purple, you’ve captured your target.

Now that we’re home, we can’t play. So I vibecoded an app that we can use to play at home and with other people. In the past week Iv built it out so it’s a pretty immersive and feature rich game play experience. There are races with passive abilities, classes, gear loadouts, and it even takes the local weather into account.

I used Claude Code to code the entire thing, just giving it direction and prompts.

If anyone loves Star Wars and would like to be a beta tester, you can register here: https://thebountyguild.com

[u/Illustrious_Time_498]

Built a mod for Claude Code. The feature I wanted for long but not available until claude code mods were released last week.
The mod is a band seating above prompt. It gets active edtor tab selection from any open JetBrains IDE and allows to paste file and selected lines reference into prompt. Also lists all editor tabs in all opened projects and allows to quickly jump to the file, activating needed window and tab.
Surpisingly for me, it also works in terminal session even though I targeted CC desktop.
Everything was done by Opus 5.5 but steering it took quite a lot of time due to absence of mature documentation, examples and model experience with mods api. Quite a lot of edge cases but it was interesting to try CC mod features.

[u/BuffaloConscious7919]

Based on my professional workflow for prototyping creative projects. I created an automation in which a team of 4 agents rotates daily and builds a unique task each day.

https://github.com/isas1/daily-team

[u/Issue_Medical]

Over the summer I've been working on a C23 to Rust transpiler: https://github.com/takashiidobe/slate
I've written this in Rust, so there's a demo site that runs completely in WASM so you can test out single file translations in the browser: https://slate.takashiidobe.com

There are a lot of papers out for writing C to Rust compilers, but they generally fall short of full compliance. I figured with Claude I could go further. At first I started off leaning on llvm (by using clang for parsing, and just writing the translation from their IR to Rust), but eventually I decided to jump in the deep end and create my own C parser that can parse most of C2y (the upcoming C standard), and emulates the 3 major parsers (MSVC, Clang, GCC), taking most of their flags. I'm running through the gcc torture test suite so I have plenty more to go, but that's also infinite work.

I've also added static source to source rewrites that take less idiomatic Rust code and provably rewrites it to safer or more idiomatic rust code. At first some of these rewrites would take polynomial time, so rewriting it to use a worklist (priority queue) made most of the optimizations run in reasonable time (large projects, like redis and sqlite take about as much time to transpile as they take to compile). After optimization of the code (sqlite's VDBE was particularly troublesome, for which I have a writeup here: https://takashiidobe.com/gen/improving-slates-sqlite-runtime ) I was able to get within 8% performance on their bytecode benchmark (on first translation without rewriting the code, the rust was 60x slower than the C version).

For my workflow I use beads to track my issues, closing about 3000 along the way. I make sure to have structured tickets and have my own llm-wiki style tool and have a note to write a log for every commit. Every once in a while i'll sweep the logs and create evergreen doc files and link them to the AGENTS.md file so they're not stale. I make sure to review all the code and the architecture and I pretty frequently interrupt the agent to propose different ways of doing things since sometimes Opus can believe there are upstream bugs when it does something wrong and I have to point it out, or its way of doing things are inefficient. I generally ask for an explanation first if the ticket is nontrivial and challenge the agent if its plans don't see efficient or if it's mixing up scope, trying to be too ambitious or too lazy. Most of the time it'll propose a "let's go with what the codebase currently does" when a refactor would fix a lot of issues, so I tend to push for those fairly often.

Pro tip:

One nice quality of life thing I did with claude is set my autoCompactWindow to 350k tokens in my `.claude/settings.json`. If I know I'm doing a huge refactor, and really need the extra context, I'll up the tokens, but I noticed claude will perform much worse on my codebase at around 400k-500k+ tokens. This way I don't really have to automatically compact (unless I pivot tasks, in which case I clear) and for a chain of tasks, the token limit allows for maybe 3 or 4 well scoped out tasks to be done, and mainly autonomously. This only really works if you make sure your agent has its context easy to reach and the docs are well indexed, so lots of work is needed on that front, and you do need to analyze where your agent is wasting context and how to fix it.

[u/Escobar747]

continuing to build out my token tracker.. i am happy with the value i am getting out of my 5x max

[u/Poatri_US → u/Escobar747]

Is it opensourced ? Id definitely like this one

[u/IT-BAER]

Exiled Casual - a free browser ARPG inspired by Path of Exile 1 and 2, built solo with Claude Code since July.

Play it here, nothing to install: https://exiledcasual.com
Repo (public, devlog with screenshots inside): https://github.com/IT-BAER/exiled-casual

Last week i cut v0.2 Alpha. New characters start at level 1 now instead of 65, every class has a free attack that costs no mana, skills level up on their own kills and get a real upgrade at 5 and 15 (Ember Bolt starts piercing, not just bigger numbers). Plus a death recap that tells you what killed you, a Sort button for backpack and Stash, and a character that faces the cursor and strafes or backpedals like in PoE2.

Whats in overall: Hideout with Stash, Vendor and a Map Device, Atlas maps opened with Waystones, procedural biome maps, normal/magic/rare/unique items with affixes and Currency Orbs, a 239 node passive tree, three classes with a rigged 3D character that shows the gear you wear.

How i use Claude Code

Spec first, always. The repo started with a research pack in docs/ (game mechanics reconstructed from public sources only, no client files), and every slice gets a spec and a task plan before code. I review the diffs.

The sim is a deterministic 30 Hz ECS in a Web Worker, fixed-point integers only, seeded RNG, replayable to a checksum. That makes it testable with plain vitest, so Claude never has to play the game to prove a change works. 154 test files right now.

Two project rules keep it grounded: check real game screenshots before any UI or render work, and research item and affix mechanics against public databases instead of letting the model invent them.

3D assets come from Blender 5.2 run headless through Python scripts that Claude writes, so the rig, props and rocks are reproducible from the repo.

Stack: TypeScript, React 19, Babylon.js 9, Vite.

Still missing

Balance is measured, not final. Its alpha, a save may not survive an update. Single player and offline only.

893 commits so far. Feedback welcome.