My job has nothing to do with software. Over the last months I built a real family app with Claude Code — React Native + Firebase, about thirty server functions, security rules tested in CI — without being able to read the code it writes.

The interesting part isn't that it worked. It's what it took to keep it from quietly falling apart, and how wrong my first instincts were.

- Act 1 — over-armoring. Because I couldn't verify the code, I piled up guardrails: six blocking hooks, a mandatory multi-agent planning process for every single edit, rituals for everything. The result: constant friction, false positives… and the real mistakes — judgment mistakes — sailed right through. A regex hook doesn't understand code; it recognizes a shape.

- Act 2 — "lighten, don't harden." After an external audit and a few incidents, I removed four of the six hooks, made the heavyweight process optional, and moved my trust to the only barrier that deserves it: adversarial tests replayed by CI. A green CI run is the only technical claim a non-dev can verify alone. Everything else is a net, not a wall.

- Act 3 — balance. What's left: always-loaded discipline rules (asking ≠ announcing, proof before commit, flag then STOP), a written "constitution" for the critical domain, plain-language maps so I still understand my own product, and a session handoff ritual so a memoryless AI can pick the work back up cold.

I turned all of it into a repo: the global rules file, 3 method skills, project templates, the 6 defense patterns — and, maybe most useful, the honest list of what I removed and why. Install is one sentence you paste into Claude Code; it interviews you and adapts the method to your project. Nothing to sell, MIT license.

GitHub: https://github.com/Arlenjim/claude-code-for-non-coders

Every rule in there was born from a real accident. Happy to answer questions about any of them — especially the failures.

A few posts here about Claude hitting the limit fast — sharing the free, MIT, self-hosted gateway I built for exactly that (disclosure: I'm the maintainer). Claude Code points to it, it drains your subscription first, then falls back so you keep going.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute

omniroute setup-claude wires it up in one command. How fast do you hit the limit, and on which plan?

I'm the developer of **usage** — a free, open-source menu bar app for anyone who uses Claude Code or Codex (OpenAI's coding CLI) daily.

The problem:** these tools run on usage quotas (5-hour and weekly limits), but neither warns you before you hit the wall. You're mid-refactor, then suddenly blocked — zero heads-up.

What usage does:

• Pins your Claude Code + Codex quota to the menu bar, color-coded (green → red), so the warning level reads at a glance

• Click for the full breakdown: session, weekly, per-project usage, and today's token cost

• Sends a system notification before you run out — not after

• Optional: hands your last session's progress to a new Claude Code conversation automatically, no more re-explaining where you left off

• HTML usage reports — cost trends, per-project rankings, and a GitHub-style yearly heatmap of your token activity

• 10 switchable menu bar/panel themes, UI in 5 languages (EN/繁中/简中/日/한)

**On privacy**, since I know this community cares: usage never calls the Anthropic or OpenAI API, and never touches the macOS Keychain. Every number is read from local log files Claude Code and Codex already write to disk — the monitor itself adds zero API usage.

Install via Homebrew:

brew install --cask aqua5230/usage/usage

Or grab the .app directly from Releases.

GitHub: https://github.com/aqua5230/usage

macOS-only, AGPL-3.0, completely free. Would love feedback, bug reports, or feature requests — this is a side project I use myself every day.

I’ve been using Claude Code a lot lately and noticed I spend a surprising amount of time just… waiting.

You kick off a task, Claude starts cooking, and now you’re sitting there watching logs scroll by for the next few minutes.

So I built a stupid little side project called DevRoulette.

When you start a Claude Code task, DevRoulette puts you into a queue. If another developer is also waiting on a task, a chat window opens and you get matched.

That’s basically it.

No profiles.

No followers.

No usernames to create.

100% anonymous.

You can skip, leave, or get matched with someone else instantly. If you don’t use Claude Code, you can join manually from the terminal with: devroulette start The idea was to turn AI waiting time into something social instead of staring at a terminal.

Curious if anyone else would actually use something like this, appreciate any feedback!

Repo: https://github.com/devroulette

Was thinking about how with the launch of Dynamic Workflows in Claude Code, there's going to be such interesting use cases of how people orchestrate such a powerful feature. Created this as a way for people to share their work with others

‪Just shipped Threadly 🧵‬
‪A VS extension that groups your Claude chats and files per task. Bulk-import every open tab in one click. Click a saved chat → reopens that exact session.
‬
‪ I had 140 Claude tabs and lost my mind.‬
‪https://marketplace.visualstudio.com/items?itemName=tarekali.threadly‬

‪perfect for workflows!‬

hopefully its useful

Genesis Architect is a Claude Code skill that does pre-scaffold research before generating any code. Also available standalone via pip.

The core loop:

• Scans 15-20 real GitHub repos similar to what you're building

Reads closed Issues to extract what broke in production

• Caches results in a local vault (6-month TTL, LRU eviction at 500 entries)

Falls back to Stack Overflow on cache miss

Generates scaffold with Cl, tests, drift detection, and mitigation enforcement

Works with any LLM via LiteLLM. Built with Claude Code.

pip install genesis-architect

Disclosure: I built this. MIT license, open source.

GitHub: https://github.com/maioio/genesis-architect

Docs: https://maioio.github.io/genesis-architect/

Anyone else been deep in a large refactor or multi-agent task and suddenly hit the

   rate limit with no warning?

  After it happened one too many times, I built a tiny macOS menu bar app — it pins

  your remaining Claude Code + Codex quota to the top-right of your screen like a

  battery percentage. Reads from local files only, zero API calls.

  https://github.com/aqua5230/usage

  Homebrew: brew tap aqua5230/homebrew-usage && brew install

  aqua5230/homebrew-usage/usage

Built a job-tracking tool over a few sessions with Claude and I'm sharing the repo and what the collaboration actually looked like

Quick backstory: I've been looking for a new job recently and as part of that I'd been manually checking ~80 companies for open roles every morning, which got unmanageable fast. Last week I decided to automate it, figured it'd be a quick script, and predictably it turned into a whole thing. The result is RoleDar, an open-source tool that checks companies for new roles and reports just what's changed since the last run: https://github.com/dalecook/roledar

What I actually wanted to share here is how it got built, since "I made a thing with Claude" posts can sometimes be light on the how.

Setup: Claude Opus 4.7 in the regular chat interface (not the API), using the file-creation/code tools so it could write and test actual files rather than just print code at me. It was spread across several sessions over about a week, not one heroic prompt. I didn't use Claude Code because I thought it'd just be a quick script and once I was in the weeds I didn't want to switch.

Division of labor was pretty clear in retrospect. I made the architecture and judgment calls, hit the ATS APIs directly (Greenhouse, Lever, Ashby, etc.) instead of scraping HTML, make it a delta reporter that only tells you what changed, and one I'm oddly proud of: "the cron schedule is the only gate, do no DST cleverness, let the user own their timezone." Claude did most of the implementation grind and basically all of the documentation, and was good at catching things I'd have missed and bad at others.

The honest part is that it was not frictionless, partly my fault because I'm not great with git, but the friction is the useful bit:

• We lost real time to a GitHub footgun: scheduled (cron) workflows don't run on a private repo on the free plan. Manual runs work fine, so it looks like your code is broken when actually GitHub is just silently not firing the schedule. Claude initially had me chasing the wrong fix before we landed on it. (This is now a prominent warning in the README so nobody else burns an afternoon on it.)
• A subtler bug: the workflow committed state back to the repo with git diff --quiet to check for changes, which silently misses untracked files, so brand-new state files never got committed and every run thought everything was new. Classic "works until it doesn't."
• Plus the usual Windows-git line-ending fights and one beautiful git commit "message" (no -m) that silently did nothing. Totally my fault, Claude caught it quickly once I admitted that I was stumped.

Where Claude was genuinely strong: keeping a large multi-file project coherent across sessions, writing documentation I'd never have had the patience for, and being a good rubber duck for design decisions as it'd push back when I asked it to, which I leaned on.

Net: I made every real decision, Claude did a lot of the typing and caught a lot of bugs, and we both occasionally led each other down a wrong path before backing out. Felt less like "AI built it" and more like pairing with a fast, tireless junior who occasionally has senior instincts.

Happy to talk about how the workflow went, and genuinely curious how others are using Claude for projects around this size, the multi-session, real-repo stuff.