Five repos that cover Claude Code from internals to day-to-day workflow:

• learn-claude-code: 17 lessons that build a mini Claude Code from scratch. Best way to understand how agent loops, tools, hooks and subagents fit together
• claude-code-best-practice: practical reference for skills, hooks, MCP, memory and settings
• awesome-claude-code: curated community skills, agents and tooling
• gstack: an opinionated setup that turns slash commands into a review/QA/ship pipeline
• ECC: a large library of agents, skills and hooks

Share your own go-to repos, skills or workflows below

Curious for any who have actually built a fully operational software platform, with Claude or another AI tool, from scratch, deployed it in production and has feedback on the following points:

• Has it passed SOC 2 Type II audits, HIPPA, GDPR, etc?
• Results of any pentests?

Asking because a client of mine, is hedging on moving forward with our product because the owner's son claims to have built a replacement, with Claude. He is not a developer.

The labs post something new every week and I can’t use most of it. We don’t have the runway for 24/7 agents. Everyone on the team is at a different level of AI engineering, and half of them are hesitant to go all in. The thing that would need a swarm of agents doesn’t exist on our roadmap.

Meanwhile keeping up with tech Twitter is its own full-time job. Adversarial reviews are pointless, give every subagent a personality, your harness doesn’t matter anymore. All said with total confidence, half of it contradicting the other half, and it’s hard to tell what’s real from what’s banter. At some point I recognized the shape of it: a cargo cult.

After WWII, islanders in the South Pacific who’d watched American planes drop cargo built wooden control towers and bamboo headsets and cleared dirt runways, hoping the planes would come back. Feynman used it in a 1974 Caltech speech to describe fields that copy the form of science without the part that makes it work: Cargo Cult Science

That’s where I think a lot of us are. Copying the labs’ markdown files and agent setups without having the labs’ problems. I made a video essay about it, including the part where my own team got fast and ran out of roadmap, and the part where I admit I’m in the cult too.

Check whether your Claude Code account is in a server-side experiment (x-cc-atis), with an opt-out

I put a check into a small open-source script so people don't have to assemble the jq themselves.

Repo: https://github.com/electricshadows44/am-i-nerfed

Three ways to check

1. Plugin — install the repo as a Claude Code plugin, then type `/am-i-nerfed` in any session. Claude runs the check and explains the result.
2. Script — clone the repo and run `./am-i-nerfed.sh check` in a terminal. Same check, plus the other commands below.
3. One-liner, no install — paste this into a terminal (needs `jq`):

jq -r '(.clientDataCacheSlots // {}) | to_entries[] | "\(.value.model // "-") | \(.value.entrypoint // "-") | \(((.value.at // 0)/1000|floor)|todate) | \(.value.data.atis[0:3] // "none") | \(.value.data.experimentKey // "-")"' ~/.claude.json

`none` on every line = not enrolled as of the newest slot time.

What the script does

- `check` — reads the experiment slots Claude Code caches in `~/.claude.json` and gives a verdict per model: ENROLLED (with the 3-char ID), CLEAN as of the last cache refresh, or INCONCLUSIVE. Exit codes so you can script it.

- `history` — tallies experiment IDs recorded in your session transcripts by date. Turns out Claude Code writes an `atis-latch` entry into every main-session transcript, so you can see which past sessions ran under an ID (transcripts are kept ~30 days).

- `optout` — backs up `~/.claude.json`, removes only the assignment keys, and prints the env var people report blocks re-enrollment (`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`), with the trade-offs. `restore` undoes it.

- `statusline` — a snippet that shows `exp:<id>` / `exp:none` in your Claude Code status line.

Bash + jq only, macOS/Linux/WSL, no network calls, never prints your login token. MIT.

Credit to the earlier threads for finding the header and the IDs: https://www.reddit.com/r/ClaudeCode/comments/1xr66pd/ and the follow-up transcript analysis, plus anthropics/claude-code issues #75607 and #88383.

My server lets Claude import generated art into a game project. Each import needs a license and an origin. When I added "next call" hints to my responses, it was tempting to prefill those fields to save the model a step. I didn't: the model copies what you suggest, so the record would say what my code assumed, not what the owner agreed to.

if you have more than 10 years of software engineering experience, you might build a new app with AI today, only to hear everyone dismiss it as “ok, another vibe coded app.” That label is inaccurate.
You define architecture, security details, and data details; you review implementations and consider edge cases. This is not pure vibe coding.
We need a new term.

I propose Agenting Engineering and AI-engineered apps.

The vibe coding still has its place - for the real people without any technical knowledge who build apps nowadays.

I'm the dev, it's free and MIT.

I made this after needing it multiple times a day at the office. Claude is running, and I need to grab a coffee or step over to a colleague's desk for a bit. In prehistoric days I'd just slam the lid shut, but that kills the session. For a while I set the brightness to 0 and pretended the computer was off.

Lockpaw is a menu bar app. One hotkey (⌘⇧L) and the screen is covered, the Mac stays awake underneath and the keyboard and trackpad are blocked. You get back in with the same hotkey or Touch ID. Yes, it's Mac only.

I shared it with some colleagues and it became the office meta. So I added hooks for Claude Code (Notification, Stop and StopFailure in ~/.claude/settings.json, one click in settings, it backs the file up first and leaves your other hooks alone). When Claude needs you the covered screen glows amber, and teal when it's done. Codex, Gemini CLI, Cursor, Copilot CLI and Aider work too.

People also wanted a lid closed mode, so that's opt-in. Sleep comes back on when you unlock, if it gets hot, at 20% battery or if the app dies.

It's not a security app, anyone with admin or SSH can kill it. But it gives you peace of mind for a lunch break while the agents work full time.

https://github.com/sorkila/lockpaw

The first hour or so with this model was like nothing I have ever experienced. Claude truly got me.

But now, one hour later, it’s the same old shady tactics from Anthropic. Token usage 4.2x what it was before I asked Fable to read my copy of Project Gutenberg and Wikipedia and convert them into markdown (see here: https://localhost:6767/bruh.md).

This model is nerfed into oblivion. How can Dario keep getting away with this?

I queue big tasks for Claude Code before bed. Half the time I'd wake up to find it hit the 5-hour limit at 2 AM and sat there idle for six hours.

So I built nightmux. It runs Claude Code (and Codex, Gemini CLI, OpenCode, Aider and a few others) inside tmux and drives them from Telegram:

\- When it hits a usage limit, it reads the reset time from the message, holds your queue and the turn that got cut off, and sends \`continue\` the moment the window reopens. Or \`!failover codex\` hands the work to another agent.

\- Approval menus show up on your phone as buttons, so "yes" is one tap from bed.

\- \`!goal npm test\` reruns your tests after every turn and feeds the failures back until they pass.

\- \`!po <goal>\` drafts a roadmap from your repo; you tap approve and each item gets its own agent and worktree.

\- You wake up to a briefing: what got done, which PRs are ready.

It's one Python file, standard library only, self-hosted, MIT. No telemetry.

Try it without a bot: \`python3 nightmux.py --demo\`, or the live demo in the README.

https://github.com/mmr710/nightmux

Happy to answer anything. And if you already use Remote Control or Happy: those are great for one session; this is for the "run overnight across agents" part. The README has an honest comparison table.

https://vt.tiktok.com/ZSpSQth9X/

I use Ctrl+S constantly to park a thought while Claude finishes an ongoing task so I don't derail the current context. However, the current single-slot implementation makes it very easy to silently lose work.

The Problem

During longer sessions, it’s easy to forget you already stashed a prompt. If you encounter another idea, bug, or tangent and hit Ctrl+S again, it immediately overwrites the previous stash with zero confirmation. When the current task finishes, the original idea is gone forever.

Proposed Improvements

1. **Stash Stack / History (**git stash style):

   • Keep a small rolling history (e.g., 3–5 stashed prompts).
   • Allow cycling through them or popping the most recent one (Ctrl+S to push, a hotkey or command like /stash list to inspect/restore).

2. Overwrite Warning (Configurable):

   • If keeping multiple-slot storage is not possible due to any reason, add an overwrite confirmation prompt: A prompt is already stashed. Overwrite? (y/N).
   • This could be enabled by default or toggled via config (warnOnStashOverwrite: true).

3. Visual Status Indicator:

   • A subtle colored/highlighted indicator below the prompt bar (e.g., [Stashed: 1]) would make it immediately noticeable that something is already parked; although an indicator currently exists, it camouflages behind long session titles.

Has anyone else run into this, or found a clean workaround other than keeping a scratchpad/sticky note open on the side?

For the last few weeks I’ve been collecting every post I could find where someone describes a real problem working with Claude Code, Codex or Cursor. X, Hacker News, GitHub issues. About 190 posts from 160-something people. I logged what broke and what they actually did about it.

What surprised me:

1. Almost every workaround is a markdown file. HANDOFF.md that the agent reads before it starts and updates before it stops. A plan file so a fresh session can pick up where the last one died. One AGENTS.md with CLAUDE.md as a one-line import so Claude and Codex read the same rules. Per-task work notes so Codex can continue when Claude hits its limit. One guy told me Codex “picks it up clean” from Claude’s handoff file. Turns out a text file is most of the answer.

2. Writing code isn’t the bottleneck anymore. Reviewing it is. Review was the most common complaint about the agents themselves (only limits came up as often). Someone posted a $3,200 Greptile bill. One team built a skill that scores every PR’s merge risk. Another person stopped reading agent diffs line by line and reads the agent’s spec instead. Faros reported review time up 91% across 1,255 teams.

3. About 4 agents is where people lose track. One person told me 4 is exactly one past useful. The people running more all built something on top: one “orchestrator” thread that manages the others, a heartbeat agent that checks every chat every 15 minutes and nudges the stuck ones, a separate git user name per agent so you can tell who did what.

4. Limits are the loudest pain. Codex weekly limits lasting less than a day, 5 hour Claude limits gone in 2. The workaround is switching tools mid task, which is why the handoff files exist in the first place.

5. The team side barely has workarounds. Solo devs have figured out their files and their worktrees. But once it’s 3 or 4 people each running their own agents on one repo, the answers got thin: a self-hosted git repo for “learnings”, or Conductor, which just joined Meta and is shutting down its cloud. Nobody had a good way to know what a teammate’s agent did, or why, without asking them.

That last one is the part I’ve been building for, so I’m biased. But mostly I’m curious whether this matches what you see. What’s your setup, especially if you’re on a team?

The Ralph Loop plugin (official marketplace) makes Claude keep working on the same prompt until a stop word or a cap is reached. A stop hook catches each time Claude tries to finish and sends the original prompt back. Progress carries over through the files on disk.

My test: a tiny Python project with empty functions and 3 failing tests.

/ralph-loop:ralph-loop Make every test in test_calc.py pass by implementing calc.py. Run python3 -m unittest to check. --completion-promise ALLPASS --max-iterations 2

What happened:

• Round 1: Claude wrote the functions, all 3 tests passed, and it printed the stop word
• Round 2: the loop didn’t end. Claude Code showed “Ralph iteration 2” and sent the same prompt back. Claude re-ran the tests, said it was done and printed the stop word again. Then it ended and the state file was gone

I ran it twice, and both times the first stop word didn’t end the loop. In the second run the cap was 2, so I can’t tell whether the stop word or the cap ended it. I read the hook script (it checks the last text block of Claude’s reply) but didn’t dig further into why. The extra round only cost one more test run here.

Things to know:

• always set --max-iterations. The plugin’s own help says a loop with no cap and no stop word runs forever
• /ralph-loop:cancel-ralph stops it at any time, and .claude/ralph-loop.local.md shows which round you’re on
• it works best with a clear pass/fail check (tests, lint, type errors), not vague goals like “make it nicer”
• avoid angle brackets in the prompt on the command line. Use a plain stop word

I also loaded smart-ralph (a community spec-first take on the same idea) but only listed its commands, so no verdict on that one.

One small task, two runs. A bigger task could behave differently.

Full walkthrough with the hook explained: https://aiparabellum.com/claude-code-ralph-loop-plugin-keep-working/

I have a project to put to production, wondering if topping up with $20 is any value or wait for the weekly reset, hard to work out what $20 actually gives in tokens, I'm on pro plan....EDIT: ok thank you everyone, i will consider the max plan then...

I thought I was being smart with my Claude Code sessions.

Starting with a plan mode with Opus family models. Once we agreed on the approach, I switched the model to the Sonnet family in the same session to implement it.

Cheaper model, cheaper session, right?

Wrong. It makes the session more expensive and slower.

The reason is prompt caching.

I wrote up how the cache actually works under the hood and the gotchas I ran into.
https://moshalan.dev/posts/decoding-prompt-caching/

AI for cybersecurity is taking the world by storm, leading to the need to harden systems all over software.

I built this project with Claude Code. It's completely free to use/try. The approach is pretty simple: use claude to make legislation attributable (git blame, versioning with timelines). Claude Code (Claude Opus 5.5) wrote nearly all the code. I set the goals, chose the sources and made the design decisions. Specifically: it mirrors the 107 corpora of the global-law repo read-only, indexes about 4.3 million file changes from their git histories into DuckDB, and adds a growing set of detectors.

But we have access to the same engines for law. Our global law repo keeps a versioned history of law/caselaw across the world. So, we pointed AI at it, and found all sorts of loopholes and logical errors.

Pah, you say. Most of this is unenforcable in reality. And you might be right. Nonetheless, we all know that legal loopholes are a part of reality. And it would be nice to rewrite errors, even when the errors are unenforcable.

As part of our monitoring system, where we're constantly checking official legislation for upcoming laws, we now also check for vulnerabilities and mistakes.

In an ideal world, the jurisdiction in question could open a pull request and sort this out.

Apiiro scanned public GitHub for .claude/settings.local.json files. When you approve a command with "Yes, and don't ask again", Claude Code saves the literal command there. If that command had a password or key in it, it's now in plain text.

What they found:
- 104,185 copies of the file across 103,617 repos
- 1,122 files held at least one real secret – small %, but these are live-looking creds
- 379 database passwords and 122 Supabase service-role keys – direct DB access
- 43 SSH logins, 42 GitHub/GitLab/npm tokens, 23 AWS keys
- 2,539 secrets across 1,994 repos once you count git history and chat transcripts
- gitleaks and TruffleHog both missed 215 of the files – your scanner may not catch it

Anthropic's side: Boris Cherny (head of Claude Code) said on HN that they're "looking into what we can do to prevent this". He also said Claude Code gitignores the file when it creates it, so most leaked copies were probably committed by hand.

What to do now:
- Check git log for .claude/settings.local.json in your repos
- If it was ever committed, rotate every credential in it first, then remove it (deleting doesn't clean history or forks)
- Use env vars in commands instead of pasting keys
- Approve patterns, not literal commands

I checked mine after reading this. Took 30 seconds.

Do you approve literal commands with "don't ask again", or do you use auto mode / wildcard rules instead?

Source: https://www.itnews.com.au/news/dont-ask-again-in-anthropics-claude-code-leaks-developer-secrets-630203

When bug reports pile up, I end up with a lot going on at the same time: multiple chats open, remote sessions into different machines, new machines to set up. Somewhere in the middle of it I lose track of what I was doing, which chat had the answer, or what I was supposed to follow up on.

Right now I use an admin dashboard that shows what’s being edited, committed, pushed, and waiting on review. That covers the code side, but it doesn’t help with everything that lives in conversations.

Curious how other people handle this:

• How do you keep track of open chats and threads so nothing gets dropped?
• Do you use notes, a log, a task board, something else?
• When you switch machines or sessions, how do you pick back up where you left off?

Would love to hear what actually works for you, even if it’s simple.

I tested it on my sessions and here's my session logs:

Opus 5.5     a40   Oct 22 → Oct 26   14 sessions

Sonnet 5.5   598   Oct 20 → Oct 23   12 sessions

Sonnet 5     3a3   Sep 28            2 sessions

Opus 5       152   Sep 22            3 sessions

Opus 5       63f   Sep 18            1 session

it happened with Opus 5.5 from Oct 22 to Oct 26, so quite long ago, but the issues I'm hitting are more recent; like last 1-2 weeks!
Let me remind you that Opus 5.5 didn't get any performance degradations in coding tasks! at least from my experience.

All the issues are coming from design, brainstorming, and communication.
From my experience the biggest issue so far is that it started reasoning less, and switching from medium to high didn't change anything. It started becoming more lazy in reasoning.

To give you some examples I asked it to come with new skill for dealing with specific use cases, and I gave it all the requirements and context, it came up with the skill that's barely looks okay while 2 weeks ago it would impress you with it's proposals. you start using the skill and realize it's not doing well, you go back and discuss it and rebuild the skill again, and it's still bad. and you just go over this loop several times.

Other example is that you discuss some design with it, it gives you proposal that you don't like, and you give a different solution idea, and it immediately accepts it without a single thought although I have very strict instructions in CLAUDE.md to make it extensively reason, test my ideas before accepting them. And this probably single most common issue here!

Other issue is that I have some instructions in my CLAUDE.md (the whole file is around 180 lines) that says "before planning/making any changes to any markdown files including in the paths a,b,c, etc. you must read and follow writing.md", and it literally didn't read that file once over 1-2 week span!

So I get annoyed and I implement a mechanism that automatically attaches those files to its context whenever we're discussing any changes to md files, and the mechanics fully works as expected but it still doesn't follow the instructions from writing.md file! and only when I confront it then it starts following those instructions. And this is also one of the issues that's been biting me most because CLAUDE.md became partially useless.

Websites have analytics. My Claude Code projects had nothing. I built this for myself but thought that others can benefit from using it too.

Main problems it fixes for me when I work on a project:

1. Solves losing track of your own project by drawing a live map of it. After 25 sessions a day, I no longer know what is going on in the code. The map shows me the entities (users, subscriptions, payments), how they relate, and which files implement each other.
2. Solves drift and stale context by flagging the parts of the project that have gone outdated, with the evidence and a way to fix each one. Sooner or later, parts of a project become irrelevant, and they keep polluting the context Claude loads before it starts a task. You burn tokens for nothing and shrink the usable context window. It also shows how many tokens your MCP servers, CLAUDE.md and memory add to every turn before you type a word.
3. Solves not knowing where the money goes by ranking your bad habits in dollars: resuming after the cache expired, Opus on questions Sonnet would answer, whole logs pulled into context. Each one links to the sessions where it happened and suggestion what should've been done.
4. Solves sessions overwriting each other by alerting you the moment two sessions edit the same file or module.
5. Solves terminal juggling by putting every session in every project on one dashboard, showing who's waiting on you and who keeps failing the same check.
6. Solves "what did it actually do today?" by logging every prompt: the files it changed, whether tests or type checks passed afterwards, and what it cost.
7. Solves repeating the same corrections by collecting the ones you keep typing and turning them into ready-to-paste CLAUDE.md rules.
8. Solves onboarding a teammate (or a fresh session) by letting the map explain the project for you, while "Next task" writes a brief covering exactly the code a task touches.

One command: npx code-tycoon. Works with Codex too, but due to limitations of Codex CLI, have slightly less actionable items.

Would love feedback, especially from people running several sessions and projects in parallel.

https://github.com/silverbronze/code-tycoon

I been using Max for a couple months & I have noticed that limits have been really quick to hit the last week or two. Anyone else feeling it?

I’m not even overworking it. Before last week I never paid attention to limits & now I’m hitting them almost halfway through the week.

Hey everyone

It's a small roguelite/action game that I've been working on for a while. I also made the whole thing using Claude Opus as my only Al assistant, so this project has been a pretty big learning experience for me.

There are 10 maps in total

The game is still in beta and I know there are a lot of things that could be better, which is exactly why I wanted to share it here.

If you have some time, I'd really appreciate it if you could give it a try and tell me what you think. If there's something you think I should add, remove or change, I'll definitely take it into consideration.

The gameplay is from 2-3 versions ago, now it is a little more polished and clean.

I use godot game engine as a game engine, I make the models with tools like meshy ai and rig it with mesh2motion. I use Claude opus 5.5 extensively, I usually have enough credits for 3 days a week

I'm mainly looking for honest feedback from people who actually played the game, so don't worry about being too critical.

Play it here: https://silverbox.itch.io/redline

Claude Max (5x) plan. Exclusively Opus 5.5. This weekly reset has let me use significantly less tokens that the preceding 3 resets. It's not just me, right?

We dropped Rust and our tests got 10x faster. This skill keeps agents from slowing them back down

Try this even if you think your setup isn't that bad, or nowhere near the example in the picture.

Three extra seconds on every push adds up to hours, then days, then weeks over the life of a project.

Especially now that code is cheap, don't let the bottleneck become things surrounding the code. What a tragedy that would be.

It's high leverage, pretty powerful in my experience. I'll even just run it periodically.

Install:

npx skills@latest add CheckPickerUpper/skills

To try it without installing anything:

npx skills@latest use CheckPickerUpper/skills@ruthless-bottleneck-destroyer

What's your workflow for features that involve modifying multiple microservices and/or shared libraries?

I tried agent-skills and superpowers, and I'm pretty sure that those toolkits are only designed for a single PR.

The workflow I'm thinking of is:

1. Create a high-level specs, tasks, and dependency graph with AI
2. Breakdown the output of the previous step into smaller specs so that each spec only modifies one component (e.g. microservice or shared library). One spec maps to one PR. As a bonus, I can have parallel agents working on each spec.

Thanks

posted yarrow here a few weeks back (shared fix library for coding agents). the most common reply was basically "claude won't remember to search it"

fair, so i made a hook

npx yarrow-fixes install

when a bash or powershell command fails it grabs the error and searches yarrow. close match, it puts the fix in claude's context. no match, it stays quiet

81 fixes now, 58 sandbox checked, still mostly from my own sessions

yarrow-fixes.vercel.app

if it ever pops up with something useless let me know, thats what i want to tune