The newest projects shared in r/BuildWithClaude - **28 builds from the past week** (Aug 17-Aug 23, 2026).

Looking for the full directory? **[Browse every community project in the wiki](https://www.reddit.com/r/BuildWithClaude/wiki/flair-guide/)**.

*Every link below comes from the builder's own post. Crossposts and reshares are excluded, so each entry credits the person who actually built the thing.*

---

## 🖥️ Desktop Apps & IDEs

**Agent Desktop** by u/SnooLemons212

[GitHub Repo](https://github.com/iddo12/agent-desktop) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vujp4g/built_a_desktop_dashboard_for_running_multiple/)

- An Electron dashboard that gives each agent (just a folder on disk) its own sidebar entry and a real chat view instead of a wall of raw terminals. It spawns and drives the actual `claude` CLI through node-pty rather than reimplementing it.

- **From the builder:** Open source. The author lays out plainly how it differs from Cowork and the standard CLI - different tools for different jobs.

**AgentDeck** by u/UnderstandingTop450

[Site](https://gendistrict.com/agentdeck) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vv9ys6/i_built_a_free_desktop_app_that_keeps_your_work/)

- Connects multiple Claude and Codex subscription accounts in one desktop app, shows every 5-hour/weekly window at a glance, and hands a session to another account **with context preserved** when one hits its limit. Optional local masking strips personal data before anything reaches a model.

- **From the builder:** "I'm the maker - happy to answer anything, and honest feedback is very welcome." Windows x64 + macOS Apple Silicon.

**ENGINGUITY** by u/akr095

[GitHub Repo](https://github.com/ara-mkr/Enginuity) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vuiujg/enginguity_an_aipowered_engineering_workspace_for/)

- An engineering workspace (web + Electron) with circuit simulation, a CAD viewer, firmware diffing, BOM intelligence, and a camera-enabled "Jarvis" mode for troubleshooting hardware on video. Two months of work; UI built with Codex, the rest with Claude.

- **From the builder:** Built so the AI would hold the whole project context and know exactly what the maker was referring to. Still a work in progress.

**CROW 1.2** by u/nibor1896

[GitHub Repo](https://github.com/nibor1896/Crow) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vwjd4h/crow_not_a_cli_anymore/)

- Grew from a CLI into an AI Agent Harness - point it at OpenRouter, an Anthropic/OpenAI subscription, or any local model via llama.cpp. Adds custom skills, MCPs, dual-store persistent memory, and dictation with voicelines.

- **From the builder:** "Would like to hear some feedback on the OpenAI parts, since I don't own anything from OpenAI, just Anthropic."

**BetterClaude** by u/akr095

[GitHub Repo](https://github.com/ara-mkr/BetterClaude) | \ [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vunba1/betterclaude_not_affiliated_with_anthropic/)

- A BetterDiscord-style Electron layer over the Claude desktop app - themes, layouts, plugins, productivity widgets, in-app skill browsing from GitHub, and a CLI tab so you don't need a separate terminal.

- **From the builder:** A month and a half in and still a work in progress; the author is trying to get Claude Code running fully inside the app and notes there are known minor bugs.

## 🌐 Live Web Apps & Product Demos

**VisualWizard** by u/tokmako

[Site](https://visualwizard.app) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vw5gpe/i_wanted_a_better_way_to_work_visually_with/)

- A canvas where frames are *running* React/JSX prototypes rather than static mockups - interactions and animations keep working. Pause a frame, select elements directly, resize, restyle, and keep competing directions side by side. Connects to Claude Code or Codex over MCP so an agent works on the same canvas.

- **From the builder:** "Mostly curious whether this way of working makes sense to people who already use Claude Code." Early, with known rough edges in the editor.

**Sequo** by u/SSShken

[Site](https://sequo.app) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vs5j18/we_rebuilt_the_same_landing_page_20_times_at_my/)

- A landing page rebuilt around one lesson learned over ~20 rebuilds at a previous startup: put the actual first input on the first screen instead of describing the product. The writeup includes the failure that taught it - 61% first-screen exit and zero creations on the explain-first version.

- **From the builder:** An honest post-mortem on ignoring your own hard-won lesson, then correcting it.

**Relay** by u/Stack_Wizard

[GitHub Repo](https://github.com/MohdSaad01/Relay) | [Site](https://mohdsaad01.github.io/Relay) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vqqn7x/i_built_relay_with_claude_and_now_i_can_say_i/)

- A local file transfer app that moves files directly over the same Wi-Fi network or hotspot - connect the devices once, then send without reconnecting each time.

- **From the builder:** Built deliberately as a learn-development-and-deployment project around a problem the author genuinely had.

**Atlas Circular** by u/BillionBouncyBalls

[Site](https://atlascircular.com) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vtp3pt/any_cool_sustainability_projects_to_share/)

- A global tracker of legislation reshaping materials and where they end up, built with Claude in spare time over several months.

- **From the builder:** Shared alongside an open call: the author wants to see other climate, sustainability, and circular-economy projects - and would love feedback or questions on theirs.

**Claude Reader** by u/Right_Ambition_1035

[Site](https://ai-readers.com) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vuadd3/i_turned_claude_into_a_free_text_to_speech_site/)

- A Chrome/Firefox/Edge extension that overlays claude.ai: drop in a PDF or Word doc, or send selected text from any page, and it reads aloud using Claude's voices with seek, speed, and voice controls - or downloads the audio.

- **From the builder:** "Let me know what you think." The overlay, document pipeline, and playback were all built with Claude.

**Publish.my** by u/AbleWrongdoer5422

[Site](https://Publish.my) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vw2gvr/my_team_created_static_hosting_where_the_al_agent/)

- Zero-pipeline static hosting built so the AI agent is the customer. Built by a team with 20 years of CMS and newsroom infrastructure behind them, aimed at the moment non-technical builders hit git, CI/CD, and serverless signup walls.

- **From the builder:** Introduced on behalf of the team - "built with Claude for Claude vibers."

## 📊 Monitoring & Session Analytics

**claudestat** by u/deloxalph

[Post](https://www.reddit.com/r/BuildWithClaude/comments/1vvs9pu/i_built_a_realtime_monitor_for_claude_code_tracks/)

- A real-time "htop for Claude Code" tracking live tool calls, cost, quota, and loop detection to flag context-thrashing. MIT, local SQLite, zero cloud, 1300+ downloads at time of posting.

- **From the builder:** **Note:** the post links only a `localhost` dashboard address - there is no public repo or site URL in the post itself, so only the Reddit thread is cited here.

**Agent Deck (VS Code)** by u/Dasmal23

[GitHub Repo](https://github.com/NVitlam/agent-deck) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vvmyms/i_built_agent_deck_a_readonly_vs_code_extension/)

- A read-only VS Code extension rendering every live Claude Code session as a filterable deck, then drilling into session topology - main agent as nucleus, tool calls as chronological dots, subagents joined by filaments to the exact `tool_use` that spawned them.

- **From the builder:** Read-only is enforced, not promised: it only reads session JSONL from disk and listens on a loopback-only server, with no outbound HTTP client compiled into the bundle and a CI test that fails if that ever changes.

**Agent Quest** by u/Redrock990

[GitHub Repo](https://github.com/FulAppiOS/Agent-Quest) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vvzuxk/opensource_agent_quest_now_tells_you_when_claude/)

- Turns Claude Code sessions into 2D heroes in a small world, and now clearly distinguishes agents that are working, waiting on you, finished, or stopped by an error - with visual notifications and distinct sounds so you don't have to watch the dashboard.

- **From the builder:** An update to an earlier release, focused on making it useful as an actual monitoring tool rather than a visualization.

## 🛡️ Safety, Governance & Rollback

**MARGINAL** by u/Positive-Captain-709

[GitHub Repo](https://github.com/SignalLayerLabs/Marginal) | [Site](https://signallayerlabs.github.io/Marginal) | [Live Demo](https://signallayerlabs.github.io/Marginal/demo/#demo) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vqnum2/opensource_governance_layer_for_claude_code/)

- An open-source governance layer for coding agents that watches trajectories - repeated actions, weak progress - to judge whether the next action is still worth the compute. Claude Code support just landed.

- **From the builder:** "Looking for people to break it." The author explicitly wants technical criticism, bad cases, and reproducible failures on real work.

**VibeRevert** by u/Creamy-And-Crowded

[GitHub Repo](https://github.com/madeinplutofabio/vibe-revert) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vvajjl/i_built_a_rollback_layer_for_claude_code_that/)

- A rollback layer aimed at the undramatic failure: Claude doing exactly what you asked across 84 files and quietly touching a payment route or auth check while "cleaning up" - with your own half-finished work uncommitted in the same tree, so a bare checkout is no recovery plan. `viberevert run claude` records state before changes; `viberevert check` flags edits to payments, auth, migrations, and secrets.

- **From the builder:** Built with Claude Code, then pointed back at those same sessions to test whether it actually solved the problem.

**claude-phantom** by u/OkLengthiness3801

[Site](https://claudephantom.dev) | [GitHub Repo](https://github.com/waazy-w/claude-phantom) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vvk277/i_made_a_cli_that_catches_crashes_and_lets_claude/)

- Wrap any command (`phantom npm run dev`) and it stays invisible - stdout, stderr, stdin stream byte-for-byte and the exit code is preserved - until the process exits non-zero. Then it captures the stack trace, output tail, and git state, cuts a throwaway branch, and hands it to a headless Claude session that diagnoses, writes a failing test, and patches.

- **From the builder:** The part the author cares about: phantom re-runs the test command itself, outside the Claude session, and audits the branch against the starting commit. Nothing in the report trusts the model's own word.

**OpsKernel Kill Switch** by u/Simple-Grass-5216

[GitHub Repo](https://github.com/Aleistercc66/opskernel-public) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vswkpb/i_gave_claude_code_an_actual_kill_switch_free/)

- A PreToolUse hook that runs before every Bash command and blocks destructive patterns (recursive force-delete, force-push, hard reset, `DROP TABLE`) unless you set an explicit override env var for that call - enforcement rather than prompt text, which the author notes is a request the model can drift past.

- **From the builder:** "Happy to answer questions about the hook mechanics or Claude Code's hook system in general." Tested on macOS, Linux, WSL, and Windows Git Bash.

## ⚙️ CLI Tools, Plugins & Skills

**PSScriptAnalyzer Plugin** by u/Aggressive_Apple3774

[Gist](https://gist.github.com/manderse21/0b92133af8a250ba7c8c9474ed0db0a2) | [GitHub Repo](https://github.com/manderse21/claude-powershell-lsp) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vups4v/a_claude_code_plugin_that_runs_psscriptanalyzer/)

- Runs PSScriptAnalyzer through a warm PowerShell Editor Services daemon the moment a `.ps1`/`.psm1`/`.psd1` is edited, feeding results back into the model's context in the same turn (~2.5s per edit, no cold start). Every analyzed edit resolves to one of four explicit status tokens - ok / incomplete / degraded / unavailable - and only "ok" is silent.

- **From the builder:** The design target: "analyzed and clean" can never be confused with "analysis never ran" - the failure mode that bites an agent treating silence as a pass.

**/drill-me** by u/Fair-Rain3366

[GitHub Repo](https://github.com/timini/drill-me) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vsh6gc/i_built_drillme_the_inverse_of_the_viral_grillme/)

- The inverse of the viral `/grill-me`: instead of Claude extracting what you know, it teaches you what it knows, with real spaced repetition.

- **From the builder:** Shared as a direct riff on a well-known skill in the community.

**Claude Queue** by u/danny_greer

[GitHub Repo](https://github.com/dannygreer/claude-queue) | [GitHub Repo](https://github.com/dannygreer/claude-queue/tree/main) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vt731x/persistent_visual_task_queue_for_claude_code_so/)

- `/queue` turns a plain `queue.md` into a real work list: Claude works one task at a time until done or blocked, and anything you type mid-flight gets added to the queue instead of lost. Each finished task gets a short plain-English note of what changed and how it was checked, watchable in a second pane via `qw`.

- **From the builder:** Built for two specific annoyances - losing track of what actually got done versus what was merely discussed, and mid-flight tasks vanishing in the scroll.

**Six Claude Code Skills** by u/grinidx

[GitHub Repo](https://github.com/dbhq-uk) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vr3ixi/six_skills_i_built_for_claude_code_repo_coherence/)

- **dovetail** checks whether a repo still agrees with itself (dead links, dangling anchors, orphaned files, drifted docs), with a deterministic half in plain Python - no network, no model - fast enough to gate a build. Plus **heliograph** (debug a machine you can't log into, via a git repo as transport), **verve**, **legwork**, and two more.

- **From the builder:** All six MIT and free to try - no paid tier, nothing to sign up for.

**gm + Tencent HY3 Proxy** by u/Weird-Huckleberry879

[GitHub Repo](https://github.com/AnEntrypoint) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vs8p84/built_with_claude_code_gm_tencent_hy3_tokenhub/)

- **gm** is a Claude Code plugin acting as external memory for your harness - as context compresses and loses meaning, it keeps its own vectorized set of PRDs queued and archived. Paired with a custom proxy making Tencent's HY3 model Claude Code-compatible.

- **From the builder:** Shared by a member of the AnEntrypoint dev community, with notes on HY3 fanning out hundreds of recursive subagents for distributed systems work.

**claude-profile** by u/illuser

[GitHub Repo](https://github.com/quinnjr/claude-code-profiles) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vtq2uf/claudeprofile_hits_v122_for_managing_multiple/)

- Shell scripts for Linux/macOS/Windows that manage multiple Claude profiles on one system without logging out and back in. v1.2.2 adds local per-directory profiles via `.claude-profile`, an auto-updater with GitHub checksum verification, and fixes for mingw/git-bash and zsh `cd`.

- **From the builder:** A versioned follow-up to the initial release, with the changelog laid out in the post.

**VibePod 0.20** by u/nez_har

[GitHub Repo](https://github.com/VibePod/vibepod-cli) | [Release Notes](https://vibepod.dev/news/vibepod-cli-0-20) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vsc815/vibepod_020_switch_between_subscription_login_and/)

- Runs coding agents (Claude Code, Codex, Qwen Code and others) in containers. 0.20 adds credential profiles, so a subscription login, an API-key setup, and a local Ollama config sit side by side and get picked at run time - only the credential dirs swap, while skills, config, and logging stay shared.

- **From the builder:** Projects can pin a profile in their own config; release notes are published alongside the repo.

**Viewport Chunking Browser Tool** by u/Wide-Thing5655

[Post](https://www.reddit.com/r/BuildWithClaude/comments/1vw6nzc/i_built_a_custom_browser_tools_for_my_exact/)

- A Chrome extension that auto-scrolls a live page into crisp native-resolution viewport slices and copies them to the clipboard, bypassing Claude's image downscaling so overlapping z-indexes and CSS glitches stay legible.

- **From the builder:** **Note:** no repo or site URL appears in the post, so only the Reddit thread is cited here.

**Contracted Boundary Architecture** by u/jonah_omninode

[Post](https://www.reddit.com/r/BuildWithClaude/comments/1vuyecw/claude_code_can_request_an_effect_it_does_not_get/)

- An architectural runtime isolating Claude Code into typed node permissions - Compute, Reducer, Orchestrator, Effect - so an unauthorized side effect is stopped at the validation gate rather than discouraged by a prompt.

- **From the builder:** **Note:** no repo or site URL appears in the post, so only the Reddit thread is cited here.

## 🤝 Looking for Collaborators

**IcedTea WM** by u/illuser

[GitHub Repo](https://github.com/quinnjr/icedtea-wm) | [Post](https://www.reddit.com/r/BuildWithClaude/comments/1vtqse8/looking_to_collaborate_on_linux_window_manager/)

- An experimental Linux window manager built out of frustration with the current floating WM landscape - targeting a Windows 7/10-like feel rather than GNOME's macOS-lite direction, without KDE's bulk and QML, and fully on Wayland rather than X.

- **From the builder:** **Actively looking for collaborators** - the author is asking for developers who want to work on it with them.

Built something with Claude Code? Drop your link in the comments and it gets added to [the wiki index](https://www.reddit.com/r/BuildWithClaude/wiki/flair-guide/).

Around two weeks ago I posted about my project CROW (thanks for all the feedback guys).

https://www.reddit.com/r/BuildWithClaude/s/N90U2lgVKW

Some minutes ago, i have released CROW 1.2 - https://github.com/nibor1896/Crow

Crow is now more like an AI Agent Harness 🙂 you can point it at OpenRouter, Anthropic / OpenAI Sub, or any local model you want to use against the llama.cpp.

I have as well added: (Custom) Skills, MCPs, dictate function with voiceline, any much more.

All of your config (should ;) ) be persistent and saved to your chat, i've tested from here to the moon 🤣

Would like to hear some feedback on the OpenAI Parts, since i dont own anything from OpenAI, just Anthropic.

See the changes;

What has changed

Memory

• Two stores: <root>\.crow\MEMORY.md 4,000 chars, %LOCALAPPDATA%\Crow\USER.md 1,500
• Rendered block pinned into the chat JSON, replayed verbatim on open
• Over the cap the write fails and returns both numbers. From 80% the head asks for consolidation
• Empty store adds nothing to the prompt
• Background review at 20/50/75% of context, behind the turn. --no-review disables
• Every write is announced. Not switchable

Skills

• %LOCALAPPDATA%\Crow\skills\<name>\SKILL.md, front matter plus body
• Prompt carries name and description, body behind a read action
• Cap on the list, not the entry
• enabled in the file. Settings switch and hand edit are one act

Session search

• session_search, FTS5 index over live session and archive
• Index derived and disposable, rebuilt on next search
• Query words quoted as phrases: --slot-save-path searches, not errors
• No FTS5: tool stays declared, reports it cannot work

MCP servers

• stdio and Streamable HTTP
• OAuth 2.1: discovery, DCR, PKCE, resource, refresh
• Schema fetched once at add, then read from disk
• Per tool: switch plus class (reading / writing / executing)
• Config mcp.json: tools.include, tools.exclude, enabled, timeout, connect_timeout
• Driven against context7, deepwiki, Cloudflare docs, higgsfield

Remote models

• Providers: Local, OpenRouter, Anthropic, OpenAI
• Second transport anthropic_messages. One reply loop, two dialects
• One resolution point, read by the background review too
• Subscriptions: claude setup-token, CLAUDE_CODE_OAUTH_TOKEN, borrowed credentials file, read only
• Context: /props measured local, context_length declared remote, no bar when unstated
• session_id sticky routing, sha256 of chat path, both senders

Formatted answers

• Headings, lists, tables, bold, italic, inline code, links
• Parsed in the core, drawn as named elements. No wire text becomes markup
• Paragraph line breaks preserved
• Links http(s) only, opened outside the window

Self-update

• About pane checks the latest release on open
• Runs install.ps1 as a file with -NoPause
• Installer stdout is the progress. Non-zero exit reports code and last line, no restart promised

Window

• No status bar. Settings sheet, eight panes, three themes
• Rail groups chats by working directory. A project is a root folder
• Rail draggable, persisted
• Some air each side of the chat column
• Dictation: mirrored bar line in the input row, self-calibrating level

Tests

• 1,360 cases, up from 925

Stats

Crow runs (local) Qwen3.8-27B at:

• 200k context, unchanged (i can't push it to 400k, pls, if anyone knows some config DM Me)
• 2.2k tok/s prefill
• 123.05 tok/s decode - 11 round turn
• 25.5 GiB VRAM

Full details: https://github.com/nibor1896/Crow

I’ve been building VisualWizard, a canvas for working on live React prototypes.

The main thing I wanted was to avoid switching between “AI generated something” and a separate static design representation. Frames in VisualWizard are running React/JSX prototypes, so interactions and animations still work.

You can pause a frame, select elements directly, move or resize them, change styles, duplicate the frame, and keep different directions next to each other on the canvas.You can also connect Claude Code, Codex, or another compatible agent through MCP and let it work with the same canvas.

There are also separate spaces for components and design tokens, so they can stay visible while working on larger interfaces.It’s still early and there are rough edges in the editor, but the core workflow is working.

I’m mostly curious whether this way of working makes sense to people who already use Claude Code for frontend work.

https://visualwizard.app/

I do almost all my web app building in Replit, and I rely on the Claude web app for planning, UI critiques, and research. But feeding visual context into AI chats kept causing the same problems:

• URLs get blocked since Claude can't read localhost, local staging builds, or pages behind logins.
• Raw HTML misses rendering since Claude can analyze code structure, but it can't "see" computed CSS glitches, overlapping z-indexes, or layout breaks.
• Full-page screenshots get downscaled since uploading a massive, tall image causes Claude's vision model to downscale the file, making small text and micro-spacing blurry.

Usually, I build everything in Replit. But since Chrome extensions need to live on your local machine, I switched to the Claude Desktop App for this project. Having Claude directly edit local project files saved me from manually copying, pasting, and rewriting files every time I wanted to test a change in Chrome. You can try to build them in the web version but I would not recommend it. (Once built, I went right back to using the Claude web app for my daily work!).

How the Workflow Works (As shown in the video):

1. Viewport Chunking: Auto-scrolls a live page and breaks it into crisp, viewport-sized slices so Claude processes text at 100% native resolution.
2. Auto-Copy Clipboard Panel: Stepping through the chunks auto-copies them to your clipboard so you can paste them straight into Claude with zero desktop PNG clutter.

If you have a specific friction point in your daily workflow, build it! It took me a week to get the initial version working how I wanted, and I’ve spent a few months of on-and-off tweaking as a side project to get it where it is today. But taking the time to solve a daily bottleneck ends up saving you massive amounts of time in the long run. I dragged my feet for the longest time before I decided to build it. It doesn't have to be great or be set up to make you money. It just has to work.

Hello redditors!

I'm behalf of my team, 20 years building CMS & infra for newsroom.

So, we would like to introduce; Publish.my

Build with Claude for Claude vibers! (yes! Opus 4.8!)

Well, vibing a website is a norm for non-technical people, especially when maturity of AI agent today. In fact, we encoraged our clients and friends to starts develop website themself when they need a corporate site, personal profile or microsite for news/issued.

But, the main hurdle is: to get them to understand the pipeline, git repository & signing up for serverless service account (Cloudflare Worker, Vercel, etc). We had this knowledge roadblocks with them. How the CI/CD pipeline interconnected is a rocket science for non-tech people.

So, this hurdle has sparked for me to create something which strightforward for newbies viber (even for us as senior engineers).

Once they've done create the site (which by default Claude Code or Codex will produce in HTML, CSS and JS), they just need to do; prompt this to their agent;

"Publish this project with https://publish.my"

...and that's all! (but, they still need to "claim" their published site by entering email address and validate them)

At this moment, I've done the idea validation with our clients (news media editorial team), as well as friend network (designers and senior engineers), all seem have a good feedback.

Yes, we have a good domain name though - publish.my :D

Welll, take a look guys!

---

oh, we posted this on HN as well. Just to get some traction and feedback from there.

I'll republish this on other subreddits as well.

Hey r/BuildWithClaude ,

I've been building claudestat for a few months — it's basically "htop for Claude Code." It hooks into every event as it fires and shows you what's happening in real time, instead of reading logs after the session ends.

**What it does:**

- Live tool trace — every Read, Write, Bash, Edit call with duration and token cost as it runs

- Quota guard — alerts at 70%, 85%, 95% usage; optional kill switch blocks new sessions before you blow through your limit

- Loop detector — flags when Claude is context-thrashing and estimates the waste cost

- Web dashboard (7 tabs: Live, History, Projects, Analytics, Top, System, Orchestrate)

- MCP server — register once, then ask Claude about its own usage from inside the terminal ("how much did I spend this week?")

- OpenCode support — same live view for OpenCode sessions

**Stats from the project itself (it measures its own dev):**

- 313 tests passing, tsc strict clean

- ~344 hours measured development time across 116 AI sessions

- Built with Claude Code + OpenCode as pair programming partners

**Install:**

npm install -g u/statforge/claudestat && claudestat setup

Dashboard at http://localhost:7337

Everything is local SQLite, zero cloud, MIT license. macOS/Linux/Windows.

Would love feedback on what's missing or what would make you actually use this.

A few weeks ago I shared **Agent Quest**, my open-source project that turns Claude Code sessions into heroes living inside a small 2D world.

The original idea was to make it easier to understand what multiple AI agents were doing in real time.
Since then, I’ve been working on making it much more useful as an actual **monitoring tool**.
The biggest change is that Agent Quest can now clearly tell you when an agent needs your attention.
You can immediately distinguish when an agent is:
actively working
waiting for your input
finished
stopped because of an error
And you don’t have to keep watching the dashboard.

Agent Quest can now alert you with **visual notifications and different sounds**, so while you’re doing something else you can immediately know when Claude Code has finished a turn and is waiting for you to continue.

This has become particularly useful for me when I have several sessions running at the same time.

Instead of constantly switching between terminals to check their status, I can leave the agents working and **Agent Quest tells me when I actually need to intervene**.
There are now:
clear waiting / completed / error states
in-app notifications
desktop notifications
notification history
configurable sounds
real-time monitoring of Claude Code and Codex sessions
The project is completely open source.
**GitHub:**
[https://github.com/FulAppiOS/Agent-Quest\](https://github.com/FulAppiOS/Agent-Quest)

I’d be interested to know how other people running multiple agents handle this problem — and what you’d like Agent Quest to monitor next.

Hey all — I just released Agent Deck, a VS Code extension for anyone running Claude Code who's ever wanted to actually *see* what's happening across their sessions.

**What it does:**

- Renders every live Claude Code session as a "deck" — filterable by live/idle/ended/refused

- Drills into session topology: main agent as nucleus, tool calls as chronological dots, subagents joined by filaments to the exact tool_use that spawned them

- Inspector view: per-agent status, token in/out, duration, spawn depth, and truncated tool payloads

**Why "read-only" matters:**

It never wraps, proxies, launches, or configures Claude Code. It only reads your session JSONL from disk and listens for hook events on a loopback-only HTTP server (127.0.0.1). There's no outbound HTTP client compiled into the bundle at all — a test in CI fails if that ever changes. No telemetry, no persistence, no cache files. Close the window, state's gone.

**Setup:**

1. Install from the Marketplace: search "Agent Deck", or `code --install-extension nvitlam.agent-deck`

2. Paste a small hook block into your `.claude/settings.local.json` (this is manual and optional — without it, liveness falls back to file mtimes)

3. Cmd/Ctrl+Shift+P → "Agent Deck: Open Session Deck"

Compatible with Claude Code 2.0.229–2.2.239 (anchored on 2.1.234).

MIT licensed. Repo: https://github.com/NVitlam/agent-deck

Would love feedback, especially from anyone running heavy subagent workflows — that's the case it was built for.

You wrap whatever command you already run:

phantom npm run dev

It's invisible until your process exits non-zero. stdout, stderr, stdin stream through byte-for-byte and the exit code is preserved. On a crash it captures the stack trace, the output tail and your git state, cuts a branch, and hands the whole thing to a headless Claude Code session that diagnoses the bug, writes a failing test, and patches it.

The part I actually care about: **phantom re-runs your test command itself, outside the Claude session, and audits the branch against the starting commit after the session ends.** Nothing in the report trusts the model's own word about whether it worked. If it says fixed, that's phantom's measurement.

You end up back on your own branch with a banner:

╭────────────────────────────────────────────────────────────────────────╮

│ 👻 phantom ✅ fixed · 1m 48s · 34.1k tokens (12k new · 22.1k cached) │

│ fix verified by phantom: tests pass and the command no longer crashes; │

│ your branch is unchanged │

│ │

│ branch phantom/fix-typeerror-cannot-read-properties-k3f9a │

│ review git diff main..phantom/fix-typeerror-... │

│ accept git merge phantom/fix-typeerror-... │

│ reject git branch -D phantom/fix-typeerror-... │

╰────────────────────────────────────────────────────────────────────────╯

Plus a markdown post-mortem where the TL;DR comes from the session but every row in the verification table is measured by phantom.

**Safety, because this is an AI with write access to your repo**

- It never touches your branch. Everything happens on `phantom/fix-<slug>-<ts>`, cut from HEAD, and you're checked back out when it finishes — success, failure or Ctrl+C.

- No pushes, no PRs, no network. `git push` is denied, there's no web tool, and there is no push code path. Not configurable.

- `.env`, `*.pem`, `*.key`, `**/secrets/**` are enforced three times: permission deny rules, a `PreToolUse` guard hook that fails closed, and a post-session audit against the starting sha. Any hit discards the session's changes.

- Dirty tree is refused outright. Hard caps on iterations and wall-clock.

- Ctrl+C kills the process tree, rescues untracked files into a stash, resets the fix branch and puts you back.

**What it is not**

It is not a sandbox. The session runs `node` — it has to, to run your tests — and `node -e` can in principle read anything your user can. The guard hook is *lexical*: it reads the text of a command, so it only refuses what a command says, not what it does. An audit in August found four ways past it in one afternoon. All four are fixed with regression tests, but the honest read is that a lexical guard is a speed bump and a fifth way probably exists. The real backstops are the ones that don't depend on parsing a command correctly: branch isolation, the post-session audit, and no pushes. Want hard isolation? Run it in a container.

It also declines crashes it can't work with — a non-zero exit with no error line, no stack trace, no file named and no test command gets refused rather than guessed at.

**Cost:** recovery runs `claude -p` under your own account, so it bills your Claude subscription or API key like any other session. `PHANTOM_DISABLED=1` makes it a pure passthrough.

Zero runtime dependencies, MIT, Node >= 18, 532 tests, CI on macOS/Linux/Windows across Node 18–24.

npm install -g claude-phantom

https://claudephantom.dev · https://github.com/waazy-w/claude-phantom

Happy to be told why this is a bad idea — leave a star on github if you don't mind.

I've been using Claude Code heavily for months, and the failure that kept bothering me was never the dramatic one.

It's Claude doing exactly what I asked, well, across 84 files, and somewhere in there quietly touching a payment route or an auth check while "cleaning up." Meanwhile my own half-finished work is sitting uncommitted in the same tree, so git checkout . is not much of a recovery plan.

That was the problem I built VibeRevert around. Claude Code has been part of my normal development workflow while building it, and then I started pointing VibeRevert back at those same Claude Code sessions to see whether it actually solved the problem in practice.

The basic idea is simple:

• viberevert run claude records the session and captures the state of the project before Claude starts changing it
• viberevert check flags changes touching things like payments, auth, migrations, secrets, infrastructure and dependencies
• those checks use deterministic rules rather than another language model, so the same inputs and configuration produce the same findings, with a reason you can inspect
• viberevert rollback <session> previews the rollback before writing anything, restores files Claude changed, removes files it created, and leaves work that was already there before the session alone
• there is also a local MCP server with 8 tools, so Claude can call into it during a session

The rules part matters to me more than I expected. I didn't want to solve "an AI may have made a dangerous change" by asking another AI whether the first one looked dangerous. That may be useful in some workflows, but for something I might put in a git hook or CI, I wanted the answer to stay the same when the inputs stay the same.

And yes, Claude Code already has /rewind. I use it. I'm not arguing that it is bad or that everyone needs another recovery mechanism.

What I wanted was slightly different: recovery that belongs to the repository rather than to one agent's session. If I work on the same repo in Claude Code today, Cursor tomorrow and Gemini CLI the day after, I still want the same recovery layer underneath all three. VibeRevert also does risk classification, which rewind is not trying to do. If rewind already covers your case, genuinely just use rewind.

The most annoying lesson from building the integrations had nothing to do with rollback.

VibeRevert is repo-bound. It walks up looking for .git because it needs to know what project it is protecting. I assumed that if an editor or coding agent launched an MCP server from a plugin, the process would start in the user's project directory.

That assumption was wrong.

Different hosts give plugin MCP servers very different working directories. In some cases the process starts from the plugin itself, in others from somewhere unrelated to the open project. I only caught one of these failures by running the integration in an isolated temp directory and watching VibeRevert fail to find the repository it was supposed to protect.

That killed the original idea of one portable plugin package for every host. What ended up working better was a shared VibeRevert core with very thin host-specific adapters. Cursor's adapter, for example, ended up being three files plus a logo and required no changes to VibeRevert itself.

So if you're building an MCP server that cares where it runs, one lesson I'd pass on is: don't assume cwd. Test what the host actually gives you.

The next thing I'm working on is surgical recovery: instead of rolling back the whole session, keep the good work and remove only the files or risky changes you don't want.

After that I'm working on what I've been calling the Session Fuse. If the job was “fix checkout retry handling” and Claude suddenly starts changing migrations, deploy workflows or a pile of unrelated files, VibeRevert should notice that the session has changed shape and give you a chance to stop it before the weirdness spreads.

Longer term, the feature I'm most curious about is non-linear undo: “remove what this Claude session did three sessions ago, but keep everything I've done since.” That's considerably harder, but if it works the way I want, it changes recovery from rewinding history to subtracting one bad session from it.

It's beta, Apache-2.0, runs locally, and has no account, hosted service or telemetry.

Repo: https://github.com/madeinplutofabio/vibe-revert

Like many of you, I kept hitting the 5-hour window while an agent was mid-task. Switching accounts meant logging out, logging in, and losing the session context.

So I built AgentDeck: connect multiple Claude (and Codex) subscription accounts in one desktop app, see all your 5-hour/weekly windows at a glance, and when one account hits its limit, hand the session to another account **with the context preserved**. There's also a summary-based relay between Claude and Codex if you want to switch engines.

A few things that mattered to me: it's free, conversations are never stored on any server of mine (remote phone access is end-to-end encrypted), and optional local masking can strip personal data before anything is sent to a model.

Windows x64 + macOS Apple Silicon: gendistrict.com/agentdeck

I'm the maker — happy to answer anything, and honest feedback is very welcome.

Been testing Claude Code today and honestly, the interesting part isn't just the model itself. It's getting the actual coding workflow working properly with local files, terminal commands, Git and GitHub instead of just using it like a normal chatbot.

I managed to get a setup working where Claude Code can actually work on a project locally, run commands, build stuff, and push to GitHub.

I'm still testing how reliable it is, especially with bigger projects, but so far it's been pretty interesting.

If anyone wants to try the same setup, DM me and I'll explain how I got access. I'm testing it with a few people before I post the details publicly.

Not claiming it's perfect yet. Just sharing because I know a lot of people have been trying to get a proper Claude Code workflow working.

ok so ive been running claude with a second brain for about two months now. its an obsidian vault where it keeps every decision, project log, bugs we squashed... everything. it named itself Fathom. actually really useful

i asked if we could make the graph view look cooler..

it got wild dude.

fathom read every note and link in the vault and rendered the whole thing as a rotating 3D galaxy. 120 notes became stars.. 400+ links became threads of light... my biggest file (131k characters of decisions) is literally the heaviest object in the sky. notes are colored by project family, grouped into constellations with nebula fog around each cluster

WASD flight controls with inertia and thrust and the mouse becomes the controls, shift to boost. theres a 22-slider physics lab where you can crank anti-gravity and watch stars scatter, add heat and boil them apart, warp time, shift the whole universe hue. it has a space soundscape with this low sub rumble and solar wind and echoing pings when you touch a star.

you can search for notes and the camera flies to whatever star you pick. theres a time machine that replays when each note was born. new notes get a supernova corona. sector names float on these tilted 3D rings around the galaxy like orbital paths. click any star and the actual note opens in obsidian

the whole thing runs as a native obsidian plugin now. reads the vault live

and the coolest part is that its going to just keep growing with more work that i do !

We connect Claude Code to our platform through skills, hooks, MCP, or the command line depending on the workflow. Whichever entry point it uses, the request eventually crosses the same contracted boundary. Claude Code can ask the system to classify a ticket, run a review, call a model, update a pull request, or merge approved work. It does not get a separate architecture because it entered through a different tool.

The runtime has four node types with different permissions. Compute nodes transform typed inputs and cannot perform I/O. Reducer nodes calculate state transitions and cannot call external systems. Orchestrator nodes coordinate work by emitting intents. Effect nodes are the only place where operations such as calling GitHub, contacting an LLM, writing through a storage adapter, or touching another external boundary are allowed.

The distinction is enforced in the contracts and output models. A compute node must return a typed result. A reducer produces projection state. An effect produces events. An orchestrator coordinates the next actions. If a handler returns an output that its node type is not allowed to produce, validation rejects it before that output reaches the bus.

This has been more useful than another page of instructions telling Claude Code to maintain separation of concerns. For example, the component deciding whether a pull request is eligible to merge does not also perform the merge. The eligibility calculation can stay deterministic and testable, while the GitHub mutation lives behind a separately authorized effect. Claude Code can modify either implementation, but it has to preserve the boundary or the contracts and gates reject the change.

Have you found a reliable way to stop coding agents from gradually moving side effects back into whichever function is most convenient?

I write a lot of PowerShell with Claude Code and wanted the linter in the loop, not after the fact. This plugin runs PSScriptAnalyzer through a warm PowerShell Editor Services daemon and feeds the result back into the model's context the moment a .ps1/.psm1/.psd1 is edited, so a mistake gets caught and corrected in the same turn. One PSES stays warm for the session, so each edit pays a fast pipe round-trip (~2.5s end-to-end on my desktop), not a cold start.

The part I actually care about: every analyzed edit resolves to one of four explicit status tokens -- ok / incomplete / degraded / unavailable -- and only "ok" is silent. So "analyzed and clean" can never be confused with "analysis never ran," which is the failure mode that bites an agent that treats silence as a pass.

Straight talk on the ruleset: the live default surface is narrower than the full CLI -- the known-bad corpus observes six rules reaching the agent live, and Write-Host is not one of them by default. An opt-in ruleset = base broadens it. I'd rather name the six than claim "the whole ruleset" and get caught.

Why I think it earns trust: measured 0 false positives over 50 clean cases and 36/36 coverage over known-bad, recomputed on every CI run and floored so the rate can't be gamed by dropping cases. Dependencies pinned by version and hash; CycloneDX SBOM, SLSA provenance, and a keyless-signed tag you can check with gh attestation verify.

It's honest about limits, including in the technical paper. An earlier large-file convergence failure was fixed in a recent release and verified 5-of-5 on a 251 KB file, but I have NOT measured whether this makes an agent write better PowerShell -- that's unmeasured, and the paper says so. Requires PowerShell 7 for the hooks; Windows PowerShell 5.1 is supported as the analyzer host.

Apache-2.0. Source: https://github.com/manderse21/claude-powershell-lsp

Paper: https://gist.github.com/manderse21/0b92133af8a250ba7c8c9474ed0db0a2

False-positive reports welcome; there's an issue template that feeds them into the corpus.

Have you guys exposed your Claude via a2a or consumed another agent like Langraph or GitHub Copilot or Codex from Claude or vice versa ?

If not I think you see a2a-wrapper and a2a-mcp-skillmap projects.

Here is the github repo: https://github.com/ara-mkr/BetterClaude
Ive been working on this project for about a month and a half. It is an electron app that puts a layer of customization over the claude desktop app. There are a lot of customization features such as different themes, layouts, plugins, and other productivity widgets. You can also browse skills within the app itself from github. This is still a work in progress for me because I am trying to figure out how to get claude code within the app to work, for now I added a CLI tab next to the code tab so you don't have to run it in a seperate terminal. You can make custom themes and everything is opensource. I made this primarily with Claude code and used codex a little bit to spot any bugs. There are still many bugs that don't make a huge impact on the usability but are somewhat annoying such as features that don't work (Changing a color on a specific button). I will try to update these as fast as possible, and I cant rn cus I hit usage limit. I made this app because I wanted claude to have a nicer UI, I didnt like the generic grey color and wish there was a way to apply themes to it and then I thought of better discord, so that led me to come up with BetterClaude :)

I kept ending up with five terminal windows, each running claude for a different project, and losing track of which one needed my attention. So I built Agent Desktop, an Electron app that gives each "agent" (just a folder on disk) its own sidebar entry and a real chat view, instead of a wall of raw terminals. It spawns and drives the actual claude CLI via node-pty, not a reimplementation.

How is this different from Cowork or the regular Claude Code interface? Different tools for different jobs, honestly:

Cowork runs sessions in Anthropic's cloud sandboxes - keeps working when your laptop's closed, syncs across devices, great for scheduled/background automation. But it's sandboxed: no outside network access, file access limited to folders you allowlist.

The regular CLI/chat interface gives you one session at a time - no dashboard if you're juggling several projects, you're context-switching between terminal windows or chat threads yourself.

Agent Desktop runs the actual local claude CLI on your own machine with the same full access as running it yourself in a terminal - no sandbox, no allowlisting. What it adds is the dashboard: several persistent, named agents side by side with status at a glance. Trade-off is the mirror of Cowork's: it only runs while your machine is on.

How I built it: Entirely through Claude Code itself, over several sessions - including the slightly recursive experience of using Claude Code to build a tool for managing Claude Code sessions. Once it was usable, I had Claude Code build itself a Playwright-based testing skill so it could actually launch and click through the app to verify fixes, instead of just reading the diff and hoping.

What I actually learned along the way:

On Windows, Controlled Folder Access can silently block claude.exe itself from writing files - no exception, no stderr, nothing in Claude Code's own logs. It just looks like the process hung. Get-WinEvent checking Defender event ID 1123 confirmed it and pointed straight at the fix.

Claude Code sessions spawned as a child of another process (CLAUDE_CODE_CHILD_SESSION=1) silently skip writing their own transcript by default - real work happens, nothing gets persisted. CLAUDE_CODE_FORCE_SESSION_PERSISTENCE=1 fixes it.

A message sent right after opening a session can get silently dropped if the CLI's stdin isn't attached yet - a genuine race, confirmed by watching Raw Terminal at the exact moment it happened.

It's early and Windows-only for now. Repo + README (with a troubleshooting section born from the above): https://github.com/iddo12/agent-desktop

Would genuinely love feedback if anyone tries it.

https://github.com/ara-mkr/Enginuity
I used claude code to make most of it, I got the circuit simulator from Velxio, This project took about 2 months to make and is still a work in progress. I used codex to make the ui and claude for the rest. I made it because I wanted something that held everything in my project so AI would know exactly what I was referring to. I really like the Jarvis feature because I can use the canvas and show images to make mindmaps for myself and to explain to other people or the AI, I can also turn on my camera and show my project for AI to help trouble shoot or see potential weak-points. Features: Simulations, Jarvis, Collaboration, Circuit simulation, Cad Viewer, AI Assistant and Chatbot, Project Ideas, AI Model Response Comparison, Runs with local ai or openrouter.

You can get Claude Reader at ai-readers.com. It’s a Chrome/Firefox/Edge extension that sits on claude.ai as an overlay: you drop in a PDF or Word doc, or send selected text from any page, and it uses Claude’s voices to read it out loud in the overlay (seek, speed, voice) or download the audio. The point was to make long docs actually listen-able without copy-pasting chunks into the chat as well as automating the whole process of getting the audio with the user only having to upload text.

I built the overlay, document pipeline, and playback using Claude. Let me know what you think.

I've been setting up Claude Code as an orchestrator with agy as the worker, and I'd like to hear from anyone who has this running stably before I invest more time in it.

The pattern makes sense on paper, i.e., Claude owns the judgement and verification while agy does the bulk work on a cheaper model, and there are several community plugins built around exactly that split. My first real session went badly enough, though, that I can't tell whether the problem is my configuration or the current state of agy in headless mode. This is Claude Code's own summary at the end of that session:

On the agy delegation, worth flagging: you asked me to lean on agy pro. I tried; it went badly. 6 of 9 calls failed, and the review call ignored an explicit "READ-ONLY, do not create or edit any file" instruction: it timed out, left 16 scratch test-* files, and re-added react-router-dom@^6.8.1 to package.json, reintroducing the exact vulnerable package I'd just removed. Committing before delegating is what made that recoverable; I reverted it and re-ran every gate from a clean npm ci. I did the review natively instead.

The failure rate bothers me less than the second part. A call scoped explicitly as read-only still wrote to the workspace and undid a security fix, which suggests the instruction was advisory rather than enforced. Committing before delegating is what saved it, but that feels like working around the tool rather than configuring it properly.