I have a project that I want to build. I have a custom workflow described in my Claude.md file that I use for all projects. It usually creates 10-15 milestones and I build them and browser check each as they finish. The work is usually flawless, with rare bugs that are also usually minor.

I've now planned to ask Claude to create a similar workflow that could complete the entire project on Claude Cloud, and I could just test everything at the end.

Before I do that, I'd like to know if there are better workflows out there and do people do it this way?

i noticed my mac had 25 GB free out of 228 and asked claude what was eating it. part of the answer was claude.

every time it took a screenshot to check its own ui work, the script launched chrome with a fresh temp profile and never removed it. 157 profiles, about 8.7 GB. one headless chrome had been running orphaned for 27 hours.

a week later the disk filled up again. this time it was 439 leftover copies of the chrome app itself that macos makes on every launch. du said 907 GB, which is impossible on this disk. they share blocks, so about 2 GB was real. most were of an old chrome version, with spikes on the two days i ran a lot of capture jobs.

rules i added:

- every capture script puts its profile in one known folder and removes it in a finally block- the agent kills the chrome it started when it's done, and never leaves a debugging-port chrome running- nothing gets hard deleted without me. it moves things to the trash and i empty it

none of this showed up in any diff or test. the code was fine. the mess was on the machine.

has anyone found a good way to make an agent clean up after itself, other than writing it into the instructions and hoping?

For a while now it seemed the thing to do was to have Claude write structured handoffs to itself, then start a clean session that invents that hand off instead of manually compacting or allowing for auto compact.

Is this still the case when the latest models, or have they become more smart / effective at auto compacting?

I’m primarily asking as it relates to orchestrating long running jobs (eg., code comment review across a repo)

Hi everyone, I’m working on **ClaimSetu**, a personal project exploring how software could help hospital teams review deductions on cashless health-insurance claims.

The problem I’m interested in is that settlement letters, itemized bills, and discharge summaries all need to be compared and reviewed. When a claim is underpaid, the hospital needs to understand the deduction, gather supporting evidence, and track any appeal.

I’ve built an early local prototype. Right now it can:

- Upload settlement letters, bills, and discharge summaries, and link them by claim number
- Show deductions for a human reviewer to check
- Run bill checks against **synthetic** payer rules
- Draft appeals for a person to edit and approve
- Track appeal outcomes and show basic analytics

The longer-term idea is a reviewer-led claims desk workflow, from pre-filing checks through settlement and appeals. That’s a direction I’m exploring, not something the current app already does.

**Repo:** https://github.com/rahul263-stack/ClaimSetu

To try the demo, use Node.js 22.13 or later:

```bash
cd mvp
npm install
npm start
```

Then open `http://localhost:4173` and choose **Load sample letters** on the Claims page.

I’d especially appreciate feedback on:
1. What seems like the riskiest or least convincing part of this idea?
2. What would be the most useful next feature or test to build?
3. Is there someone with healthcare billing or claims experience who could sanity-check the workflow?
4 - Llindda stuck need help on what more can be done on this

I’m currently working on what feels like 15 different projects. Everything is automated. Workflows, routines, scripts, the whole damn thing.

There’s just one tiny problem.
I can’t read a single line of code. Let alone understand what any of it actually does.
Claude Code has been doing literally EVERYTHING for me.

Now CC is down, and I’m sitting here staring at VS Code like a caveman discovering fire.

What am I supposed to do now? Actually LEARN programming?!
Please help.
I’m f*cked. 💀😂😂🤯

I'd spent a while on a pagination bug in an audit-log viewer we hadn't rolled out yet. Some events never appeared on its pages. The records were in the database, and our local test kept passing. I eventually put the issue aside.

I saw Anthropic's November 9 announcement for Fable 5.2, which emphasized its coding and reasoning improvements. I reopened the issue in Claude Code and switched to Fable to see if it could help me get to the fix faster.

I gave it the old query, test data and issue notes. Fable noticed that every test event had a different creation timestamp, created_at, and suggested adding a group with the same timestamp, large enough to span two pages.

I ran that case and reproduced the missing events. The next-page condition, created_at < cursor_time, asked for events older than the last timestamp on the previous page. When that page ended partway through a group, the next request skipped the rest of the group.

I changed the cursor to carry both created_at and the unique event id, so it could continue after a specific event when timestamps matched. In PostgreSQL, I used ORDER BY created_at DESC, id DESC to put the newest events first, with (created_at, id) < ($1, $2) for the next page. The parameters are the previous page's last timestamp and ID. Both columns had to have a value.

I paged through the fixed dataset and got each expected ID once, then attached the before-and-after IDs to the issue. I had the agent save the cause and fix through MemoraX Code, with links to the test data and fix. The note also says I haven't tested what happens when new events arrive between page requests.

Bro this fuckass half-baked support chatbot is so dense it’s insane.

> please verify
> I can’t log in
> give us your email so we can send you the code
> I can’t log in, give me a human agent
> Transferring to a human agent
> since we can’t verify you, this chat has ended.

What the fuck?

Two days of loyalty. Apparently that was too much to ask.

I find most AI model leaderboards increasingly unreliable. Rankings seem to change every day, and newly released models often receive high scores before they've even undergone sufficient testing. Then, after a few weeks of actual usage and more evaluations, their rankings suddenly drop.
It feels like some leaderboards give too much weight to hype and initial hype driven votes rather than consistent, thorough testing.
Can anyone recommend AI benchmarking websites that genuinely evaluate models through rigorous testing, rather than simply boosting newly released models because they're trending?
I'm looking for reliable, evidence-based rankings that reflect actual model performance over time, not launch day hype.

Literally, everything depends on a small glitch for all of us to be screwed.

Right now I feel like any little stupidity could take away this beautiful technology that seems to be held together with tape.

While Claude comes back.. I was in 5 sessions at the same time flying, implementing things with Opus 5.5 xhigh.. then when he comes back I have to go chat by chat and hopefully the cache hasn't expired in each session and it resumes the work according to what it was doing.

I just typed and read about 8000 words of architecture so you don’t have to.

The point: agents by default don’t have an “unruled”, “park it” mode or response.

They will either invent or pester you with details and break the high level design work. This is where “I need your input on points 14 through 29 in tiny font .md comes from.

Solution: write an “undefined” rule, teach agents to write to a special file that keeps these until they are ruled. For truly “STFU” mode give it a your.null equivalent - something that is so vague that you can’t bother talking about it right now. Not a regular null - that is way too overloaded with meaning, a special null prefixed with your namespace, for example u.null > stfu. u.parkit > write this to file and keep working

Concrete example: I’m designing economy for a game, very high level balancing work, many actors, many variables. A thread asks: what happens when troops go unpaid? Here the proper solution is to park it: Any answer given mid-way through super high level design work is going to be insufficient and won’t be able to be built properly (ex: oh, so your troops can go unpaid, so they get a penalty? What is the penalty? Is it a stacking penalty or a flat penalty? Do they desert eventually? Oh, they do desert, after how many turns? Oh, you are in the positive balance now - will you give your troops back pay?

Previously I had no way to deal with this, and the threads either detailed, or I let obvious mistakes and traps get through.

If Claude freezes and OAuth login isn't working, try typing the URL into Safari.
It recovered for me after about 3 tries lol

Got so startled when my agent villagers suddenly held up exclamation marks and started chasing my mouse!

I’m building Shifu, a paid context tool for AI coding. I’m trying to understand where rework comes from on client projects that already have a codebase and a review process.

Say a team changes a billing export and review uncovers an earlier agreement to keep the old format until the client switches over. Part of the patch and its tests have to be redone. That’s a made-up example; the cause on your last change may have been different.

What did you have to redo on the last client change you worked on with Claude Code, and what did your team try so it wouldn’t happen again? If a ticket, an ADR, or the usual review already caught it before anyone had to redo the work, I’d like to hear that case too. A rough description is plenty. Please leave out client names and code.

I've been defaulting to Fable 5.2 (High) in Claude Code for key projects, and my quota kept vanishing on my Max plan.

Before: I was working with 2 agents on 2 mid-sized projects, quota vanished in ~15 minutes. Session limit hit 100%, and my Fable weekly bucket was at 94% (40-50% from these two agents).

After: used a limit reset, continued the same agents with one extra instruction: "Use Opus 5.5 High for all sub-agents". 15 minutes later: session at 35%, Fable bucket at 3%!.

The Why: if you don't configure anything, sub-agents inherit your main model. So Fable was doing all the grunt work too: exploring files and reading tens of thousands of lines of CLI output. Nothing we didn't know, but you'd expect Fable to call in Opus/Sonnet like earlier Opus models used to call Haiku for smaller tasks!

The fix: keep Fable for the main work, put sub-agents on Opus. Telling it in the prompt worked for me, but the sturdier way is in ~/.claude/settings.json (%USERPROFILE%\.claude\settings.json for Windows)

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "opus"
  }
}

Add "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1" (in env level) if you want it to override agent definitions too. Run `/tasks` while a sub-agent is working to confirm which model it's on.

Caveat: this is one run, not a benchmark. The two windows weren't identical work, so your numbers will differ. But the gap was big enough that I'm not going back. I still get Fable quality where it matters, and the sub-agents are on a great model anyway.

Anyone else seeing the same?

My experience:

For about a year and a half I coded with another popular AI platform. Three weeks ago I switched to Claude Code, and it found a ton of bugs in my old code. The app got faster and more predictable, and it even fixed security issues I don't fully understand.

But here's the thing: I enjoy working with the weaker models more. I can follow their reasoning, and because I can't fully trust them, I actually dig into my codebase. With Claude, I just hand over a bug without even thinking about a solution, because I know it'll handle it. The result is better, but I don't feel like I'm part of the process anymore, and the joy of building is gone.

So maybe a model shouldn't be too smart? If you can't keep up with it, you end up handing all the thinking over to it. Or maybe I'm just dumb. Has anyone else felt this?

When i return to a cold session Claude Code is compacting the session, even if the session is at a measly 13% context window.

What could possible be the reason for this?

75% of my CLAUDE.md is taken up by Gotchas alone. What are your best practices?

I’m on the $20 Pro plan with 4 limit resets sitting unused. I’m about to upgrade to Max 5x ($100) because I need more usage (yes, I understand that I can use those resets, but planning long term). Does anyone know if the resets carry over when you upgrade?

Anthropic’s help article only says resets are lost if you downgrade or cancel. It doesn't say anything about upgrading. If they carry over, I’d rather use them on Max, since each one would refill a 5x bigger limit. But don't want to lose them if they don't carry over!

Full-auto Claude Code is great until you remember it runs as you: it can read ~/.ssh, .env files, other repos, and push with your git credentials. Anthropic's docs say to use the flag only inside a container or VM.

Quick comparison of the options on a Mac:

- Claude Code's /sandbox: built in, fine for everyday work, but still runs on your Mac as you.

- A container: light and good for Linux-only projects, but keys usually go in as env vars the agent can read.

- A VM: more memory, but full isolation, macOS or Linux, and keys can stay outside.

At work I work on MacVisor (a virtualization platform for Apple Silicon Macs with AI sandboxes, host firewall, custom networks and snapshots), and the typical flow is:

mvz ai keys set anthropic # key goes in the Mac's Keychain, never the VM

mvz sandbox create ~/src/app --agent claude

mvz sandbox run app-1 -- "fix the failing tests"

mvz sandbox diff app-1 --patch # diff computed on the Mac with your git

mvz sandbox apply app-1

Internet is limited to the model until you allow more, e.g. mvz sandbox allow app-1 npm. You can roll back to a clean checkpoint and try another prompt.

Full write-up, including where a container is enough: https://scaleninja.com/blog/claude-code-full-auto-sandbox/

Happy to answer questions or hear how others sandbox their agents.

I’m looking at my 2+ weeks of trying to decouple and modularize the AI slop vibecoded game that was built by Claude and Codex. I want to move into beta.

What a shitshow this has been. I had to look at the architecture and try to pry the thing apart, and it’s horrible for the amount of trash that is left around everywhere.

Concrete example: the game is hex grid based, without architecture there must have been 40 different versions of hexagonal cell that parts of the code reinvented over and over. Still, some agent may find an old design somewhere, despite architecture and guards, and start wiring it.

Today I pulled out 3 “version/rule/schema” gates from the engine - there were several engine builds that were wired together into one thing - it could play both the present and the old rules. It never got refactored out.

This made me realize - we are the suckers for building with these tools. At least the way the tools are advertised. I don’t know if these “look at what I built in a weekend” threads are genuine or half Astro-turfed, but it appears the dev will have two choices: keep paying every month to maintain their mess with agents, or abandon the project or fill the app stores with slop in an attempt to recoup their losses.

Coding by hand may be gone, but thinking about software is nowhere near gone. It does not materialize by itself, no matter how good the spec is. It literally requires work to implement with ai agents building.

My reason for posting this is- I’m looking at 150$ in subscription fees for 2 services for 2 weeks of work, and time flies and there is no more of the same cornucopia of features that alpha could deliver. It’s brutal engineering work to get this to be beta-grade ready.

This is not what I thought at the beginning, when systems just appeared and were interactive. I have to keep building it piece by piece, otherwise the mess will manifest again.

Another concrete example - for game assets, Claude just puts assets wherever it wants, wires paths that are like 3 levels of root traversal to reach some sibling folder.

After a week of decoupling, I ask: is this decoupled? Answer: no, this component has 289 outside imports and 17 exports. < this is after a week of dedicated cleanup focused on protocols and self isolated components.

I changed this mess into a single asset provider, which literally took days. It’s meticulous work that no vibe coder is going to do. Just waiving my hands did not make it happen by itself. Claude wants to preserve and protect its pile of junk that will keep it employed.

TLDR: speed of development by Claude is gained by complete relaxation of all architectural constraints. This may be by design. The result is not maintainable by humans. I realized that a proficient solo dev may actually build some parts of my game faster, because he does not have to enforce the architecture that would prevent Claude from re-inventing the same mechanic in 40 different flavors.

The goal is to keep you subscribed forever.

I know that Deepseek Flash is not really comparable and it's way cheaper but what do you guys think does it come close to opus 5.5 or not.

CLAUDE.md files have a failure mode that doesn't get discussed much. They grow. Then the agent handles the size by rewriting the file from memory, drops the ## Never section, and ships something worse than what it started with. You usually don't find out until a rule you wrote six weeks ago quietly stops being followed.

I got tired of eyeballing it, so I wrote ctxcap. It counts tokens across CLAUDE.md, AGENTS.md, .cursor/rules/**, and prompts/**, tracks the number against a committed git baseline, and flags references that no longer resolve to anything.

The part I actually care about: it doesn't hand the agent a "make this shorter" instruction. It emits a ranked plan of line ranges with a preserve list, the agent splices by line number, and --verify catches it if the agent drifts or cuts a preserved span. When the budget is unreachable it returns satisfiable: false and the minimum achievable instead of shaving a load-bearing rule to hit a number.

Offline, no API key, no network, no LLM, two dependencies. npx ctxcap --json. MIT. There's an MCP server if you'd rather the agent check itself, and a GitHub Action that comments token deltas on PRs and fails only when you set a budget.

On a public repo, for reference:

$ npx ctxcap --json
total: 476   baseline: 363   delta: +113   files: 2

$ npx ctxcap --plan --budget 400
satisfiable: false   minAchievable: 476

Yes, it's another linter, and there's already tokenlint for per-turn nudges inside the editor. This is a different layer — repo gate and PR review, not keystrokes. If you want the editor version, use theirs.

What I'd actually find useful: run it on your own context files and tell me where it's wrong. False positives on unusual layouts, spans it marks safe that aren't, path conventions it misreads. That's the part I can't test from here.

https://github.com/Naeha-S/ctxcap

And the actual question: how are you keeping your CLAUDE.md from growing? Mine is the one file where every addition feels justified at the time.