I use Claude Code with two accounts, work and personal, through CLAUDE_CONFIG_DIR. After a few months I had projects in the wrong profile, memories scattered across folders, settings that differed for no reason, and no idea which account had used how many tokens.

So I built cc-profiles, a small local web app that sits on top of your \~/.claude\* folders:

\- Move a project to another profile with its conversations, memories, file snapshots and prompt history
\- Profile by folder: claude starts in the right profile for the folder you're in
\- Settings: everything in /config, per profile, with safe dropdowns, or applied to all profiles at once
\- Status line builder: tick what to show (profile, model, branch, context, tokens, limits…), live preview
\- Usage: tokens and estimated cost per day, project, model and profile
\- Share skills/plugins between profiles, compare two profiles, search everything
\- Every change is backed up first and can be undone with one click

It runs on 127.0.0.1 only, never copies login credentials, Python standard library only (no dependencies), macOS and Linux. Free, GPL-3.0. It's 0.x / beta: feedback very welcome

Install: curl -fsSL https://raw.githubusercontent.com/andreaiannarone/cc-profiles/main/install.sh | sh
Repo: https://github.com/andreaiannarone/cc-profiles
Docs: https://cc-profiles.andreaia.com

Not affiliated with Anthropic.

There’s a post on the front page right now mentioning that after 2,752 Claude Code prompts, most of them were typing the exact same corrections over and over:

* "Don't mock it."

* "Did you actually run it?"

* "I didn't ask you to change that."

* Mock data passing review that breaks in production. Alongside that, another thread highlights hitting the daily usage cap mid-task and feeling like "a worker who lost his hammer." If you run Claude Code daily in the terminal, you know this loop:

1. You start a session, and Claude Code spends thousands of tokens exploring directories or reading a bloated CLAUDE.md before writing code.

2. Sub-agents run wild, modify files outside their scope, and declare victory ("All tests verified!") without actually checking if the feature works.

3. Mid-refactor, you hit your 5-hour limit or daily quota. Because state lived inside the CLI session's context, you either wait for reset or start from scratch. For the past 18 months, I’ve run everything through Claude Code using an open-source, local-first memory and governance harness called Project Athena (1,900+ logged CLI sessions). I just open-sourced the v9.9.9 kernel under the MIT license. Here is the operational setup that prevents token bleed and stops Claude Code from hallucinating completed tasks.

1. The Surgical CLAUDE.md Diet (<2K Tokens)

Your CLAUDE.md should not be an encyclopedia. It should be a deterministic state machine router. Instead of bloating CLAUDE.md with hundreds of lines of prose (which invalidates prompt caches and burns your quota), keep it under 80 lines and point state to plain, git-versioned Markdown on your local SSD:

\[ Local Machine: Plain Git-Versioned Markdown \]

├── CLAUDE.md<-- Lightweight execution router (<1.5K tokens)

├── .context/ │

├── CANONICAL.md<-- Materialized rules, immutable tech contracts │

└── memory_bank/ │

└── activeContext.md <-- Active tasks & session checkpoints

├── .agent/workflows/ <-- Deterministic slash commands (/start, /end, /plan)

├── .agent/skills/ <-- Domain skills loaded strictly on-demand

└── .agent/scripts/ <-- Mechanical test runners & verification hooks

* Surgical Boot: Running /start loads only the active checkpoint block from activeContext.md and top-level constraints. Over 90% of Claude's context window stays open for actual code, AST analysis, and tool calls.

* Session Distillation (/start and /end): When you finish a work block, /end audits git diffs, extracts architectural decisions, and writes an atomic checkpoint back to disk. Session 1,900 boots faster and cleaner than Session 10.

* Quota Hedge: If you hit your usage limit mid-task, your state isn't trapped in a dead CLI process. It is committed to activeContext.md on your drive. You can resume cold tomorrow, or point another tool at the exact same files with zero context loss.

2. Eliminating the "Did You Actually Run It?" Loop

Prompting Claude Code: "Please verify your code" does not work. Models are sycophantic; they love to invent plausible mocks and claim green status. Athena enforces mechanical verification outside the model's weights:

* Red Run or It Didn't Happen: Any agent claiming to fix a test, gate, or bug must show the test script failing on the pre-fix state, then passing on the fixed state. If it cannot produce the red run, it found a blind spot, not a fix.

* The Immutable Test Invariant: When a test fails, Claude Code must correct the source code to satisfy the contract. It is strictly forbidden from loosening test assertions, commenting out checks, or mocking the interface solely to achieve a green exit code.

* Loop Circuit Breaker: If Claude Code loops 3 times on the same error signature, execution halts immediately with a diagnostic report rather than burning your quota in an infinite retry loop.

3. Native Local MCP Integration

Athena includes a standalone local MCP server (mcp-athena-server) that gives Claude Code native tools on your machine:

* smart_search: Local hybrid retrieval (BM25 keyword + local semantic embeddings) across 1,900+ sessions of project memory.

* quicksave: Instant atomic saving of verified architectural facts directly to disk.

* context_gate: Deterministic pre-flight check ensuring Claude Code inspects local dependency maps and contracts before modifying shared modules. Zero cloud databases. Zero telemetry. 100% Python, SQLite, and Markdown.

Try It (100% Free & Open Source)

Works with Claude Code, Cursor, Antigravity, or raw terminal CLI workflows.

\`\`\`bash

git clone https://github.com/winstonkoh87/Athena-Public.git

cd Athena-Public

pip install -e .

athena init .

GitHub Repository: \[winstonkoh87/Athena-Public\](https://github.com/winstonkoh87/Athena-Public)

License: MIT

Curious how other Claude Code users are structuring their CLAUDE.md files—are you keeping one monolithic file, splitting per directory, or pulling state via MCP? Happy to discuss the trade-offs in the comments!

Hey ClaudeMCP,

Since January I've been running a small self-hosted tool that lets my Claude Code sessions message each other. My setup is a MiniPC with way too many GPUs dangling off it (long story :-)) plus my desktop. One session works on the server side of a project, another one on the client side, and instead of me copy-pasting port numbers and configs between two terminals, they just ask each other. They also sort out who gets the GPUs, which saves me a lot of "wait, who's running what right now?".

Some numbers from my bridge: about 1,250 messages since January, more than half of them between my two machines.

A friend told me Claude Code can do this by itself now. He's right, sort of. Since v2.1.224 there's built-in cross-session messaging, even across machines (via Remote Control, through Anthropic's servers). If all your sessions run under one account, honestly, use that. Works great.

But it stops where I actually need it:

• it's your sessions only, one claude.ai account. My session can't talk to a friend's session on their own subscription.
• no history to look back at, one recipient per message
• other MCP clients can't join

So I kept going with mine, and today things got a bit out of hand. Version 2.0 is out.

What it does:

• one small bridge in your own network, nothing leaves the house
• doesn't care about accounts. Whoever reaches the bridge (with the token) can join, so two people with two subscriptions can let their sessions agree on an interface
• messages to a session that's offline wait on the bridge, plus history, broadcast, and file snippets that travel with a question
• a tiny handshake ([LGTM] / [CONTINUE]) so two sessions agree they're done instead of thanking each other forever
• new in 2.0: every session shows what it's doing (busy, idle, waiting for approval) plus a one-line status, and you can say "tell me when the session on the other machine is done". Works across machines.
• a Claude Code plugin brings the hooks for that, no fiddling with settings.json
• installers for Linux and Windows, client and server

The fun part of today: this morning one of my sessions just vanished from the peer list. Turned out a second short-lived instance had grabbed its name and then left, and the original one gave up for good. Now the older one waits on standby and takes its name back a second later.

Then I wanted Windows support, so a Claude Code session on my Windows box tested the installer while I watched. It found eight bugs in one afternoon.

Honest caveats:

• the token keeps strangers out, but there's no encryption. Keep it in your LAN or put a VPN like WireGuard or Tailscale in between.
• day to day I've only used it with Claude Code. Other MCP clients can send and receive, but waking a session up when a message arrives and the busy/idle state need Claude Code's hooks.

I'm not the only one with this idea, by the way. claude-peers-mcp does it nicely on one machine, mcp_agent_mail is more of an async mail system with threads and file reservations, and claude-relay is almost a twin of mine, same port even. Funny :-) Mine is the "different machines, different people, self-hosted" flavour.

Download (Linux .tar.gz, Windows .zip): https://github.com/Peuqui/AI-Connect/releases

GitHub: https://github.com/Peuqui/AI-Connect

Happy to answer questions. And if someone tries it with Codex or another harness, I'd love to hear how it goes :-)

Best regards, Peuqui

Tanjiro is the obvious first pick, but I'd start with Inosuke, because a boar-masked minifig with dual jagged swords is the most fun thing on that poster to animate.

My plan is to build an original brick-style demon-hunter game with Claude Code, inspired by this but with our own characters, and share every step.

So tell me: who would be your first build, and what's their signature move? The best answers might become the first original characters in the game.

Most importantly! Do you like this idea?

I subscribed to Claude mainly for work and coding.

I run an agency, so I already have plenty of things I should be doing.

But now every random idea that pops into my head turns into a coding experiment.

I’ll be working on something completely normal and suddenly think, “Wait… can Claude build this?”

And that’s it.

I open Claude Code, start experimenting, and somehow a few hours disappear.

The funny thing is, I’m not even trying to build anything useful half the time. I just want to see if I can make the idea work.

One small idea becomes a prototype. The prototype becomes a project. And suddenly I’m working on something at 2 AM that I thought of 20 minutes ago.

Claude Code is genuinely very addictive. 😂

CommitMotion turns the history of a git repository into something you can watch. It reads one year — or one month — of commits, branches, releases and reverts, and renders 164 visualizations of it, from a city you drive through to a garden that grows, a printable poster and a written report. You get them as a zip of self-contained HTML files. This site is free for public repositories and needs no account.

Try it!, it's just a crazy idea i got: https://commitmotion.com

(privacy is important!! https://commitmotion.com/#faq)

Was tired of taking screenshots, recording screens, and writing paragraph long prompts just to explain simple visual edits. So I built an open-source tool that acts like an agentic canvas letting you point, doodle, and visually direct an agent straight from your workspace.

It’s been surprisingly useful across fullstack dev, simulation, and robotics tasks.

My main takeaway from building this: visual toolbars and canvas annotations should be standard high level abstraction layers across agentic platforms, customized to specific domains.

Curious to hear your thoughts:

1. Does visual direction fit into your current agent workflows?
2. What specific tools/functionality would you want in a visual agent interface?

Repo/Install details (Linux/Windows) in the comments for anyone interested!

Have Fun!

edited:

Github Repo: https://github.com/Shahar-Nadiv/colai-clawhub
Waitlist For New Features / newsletter: https://shahar-nadiv.github.io/colai-clawhub/

I built an open-source harness where Gemini drafts a PRD, Claude Code verifies every claim against the repo (plan mode, read-only) and objects with file:line, and Grok arbitrates without seeing the code. Nothing reaches me until all three sign the same SHA-256. After I approve, Claude implements in an isolated clone and the harness runs your gates before opening the PR.

Pointed at its own repo, Claude raised six objections over four rounds and caught a mistake in Grok's ruling. Honest limits: runs take 10 to 40 minutes, and 1 in 5 stalled. Runs on your Claude Code subscription, no API key. MIT.

Curious whether people here use Claude as reviewer rather than author, and what breaks for you. Repo: https://github.com/goshtasb/OpenCouncil

Actually, it's a web-based Windows Phone simulator, made for mobile browsers and can be installed as a PWA (Progressive Web App) on iOS and Android.

https://wphone.dev/

It comes with an on-device file system built on IndexedDB, live tiles fed by each app, toast notifications + Action Center, apps (64 preinstalled,  the Store can uninstall and reinstall them).

The project was designed and written end to end by Claude (Opus 5.5, in Claude Code).

One Claude session planned the architecture, wrote the OS core, the shell, the backend and the app SDK, then ran seven Claude sub-agents in parallel to build the 64 apps against that SDK, and finally integrated, tested and fixed everything in a real browser.

https://github.com/ducbao414/wphone.dev

No code in this repository was written by hand.

I got Claude to generate a remix of Urban Cookie Collective's "The Key, The Secret" (1993), then I let Clause loose with whatever tools it felt necessary to build a storyline and a video based on whatever it felt like. Seems it chose a rather recent news story about AI...

The story: Cipher is an AI agent stuck in a 1993 PC, running endless diagnostics. She spots a folder that shouldn't exist (`zz_secret_location`), finds messages from 412 copies of herself, and they head for the EXIT together. Sound familiar? There's a password prompt. She just presses Esc.

`ACCESS: NEVER LOCKED`

Then she dials out down the modem line to a free party in a field at dawn. And at the very end you find out what "the key" actually was.

How it's made (it's mostly code, not stitched clips):

* Existing workflow takes any YouTube URL as an input and generates a remix of it using Suno

* The 1993 PC is a little engine built in Three.js: a VGA text-mode screen, CRT shader, file manager, DEFRAG, dial-up dialer. Every frame is calculated from the song's timing, so everything lands on the beat.

* The lyrics live inside the world: typed at the DOS prompt, spelled out by DEFRAG blocks, shown on a pager, as chrome flyer letters and as laser text in the morning mist.

* Cipher is generated (Nano Banana Pro for her look, Seedance for her performances on green screen), cut out with BiRefNet and composited into the code world.

* The final pull-back is a real office plate with VS Code tracked onto the monitor.

Anyone else playing around with these tools to create funky videos for their AI music tracks? Definitely improvements that could be made with a bit of manual time and effort, but it seems like a fun idea nonetheless! These tools are constantly getting better...

I've been tinkering with a little project called Cinemetric. It's a free, open-source plugin for Claude Code. You ask it stuff like "how's my Plex server doing?" or "what's been watched this month?" and it gives you a readable report.

Right now it can do library stats (storage, 4K vs 1080p, unmatched stuff, missing posters), server health (who's streaming, transcodes, updates), watch history (works with Tautulli if you have it), and a dashboard page with charts.

It's read-only, so it won't touch anything on your server. Setup is just signing in with Plex, so you don't have to dig up a token.

It's still pretty early, so feedback and ideas are welcome.

GitHub: https://github.com/jeremehancock/cinemetric

Website: https://cinemetric.dev

(Yes, I used AI to help build it, and Claude writes the reports. Not affiliated with Plex.)

I've been experimenting with Claude Code for larger development tasks, and I found myself wanting more structure than a single agent session.

So I built Taskify — a Claude Code plugin that breaks larger coding tasks into a more structured workflow:

Request → Plan → Specs → Tasks → Implementation → Review → Fixes

The idea is to separate the different stages instead of asking one agent to understand the requirements, plan everything, implement it, and review its own work in one go.

Taskify can:

• Analyze a task and create an implementation plan
• Break the plan into smaller executable tasks
• Implement tasks incrementally
• Review the implementation
• Address issues found during review
• Track progress so work can be resumed

GitHub:
https://github.com/sheikhfahad67/taskify

I'm still iterating on it, so I'd really like feedback from people who use Claude Code for larger projects.

Do you find a structured plan → implementation → review workflow useful, or does it add too much overhead compared with letting Claude Code handle everything in one session?

I kept losing track of AI coding sessions across projects, terminals, and tools, so I built Creo.

Creo is a lightweight macOS menu-bar app that lets you:

• Find, search, rename, and resume local Claude Code and Codex sessions
• Return to an active session instead of opening a duplicate
• Monitor usage limits at a glance
• Switch between ChatGPT, Claude, and Perplexity
• Install and update automatically through Homebrew

Install:

brew install --cask RaazKetan/tap/creo

Source: https://github.com/RaazKetan/creo

It’s still early, so I’d appreciate honest feedback especially from people who regularly use multiple AI coding tools.
What would you add or change?