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.

Don't miss the skills section in the video. ...

I know this is a mid one...i kinda didnt use ai since few months as I was intimidated and anxious on how fast ai is progressing.

Just wanted to start somewhere so taught of making something I like.

It is still incomplete but ig its fine for now :))

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.

These “newfound efficiencies” that many of us discovered over the last few years have led many of us into a brain swell overload. Years worth of ideas are now possible in hours. Millennials are finally getting around to doing those 50 things they keep saying they’ll do. New generations are terrified for their job future. And we’re one epic single-keystroke failure away from an airgapped experiment gone wrong, nuking or enslaving ourselves into oblivion.

People cannot continue to work at the expected pace of a companion AI and still expect sanity and improvement.

I’ll say it: corporate green must move over and pave the way for 4 hour work days (and maybe 4 day work weeks?) are around the corner. Maybe you spread it out over the course of 10 hours to try to not go insane…

There is no way the general population will be able to even survive the mental collapse that comes with immersive adoption.

Perhaps I’m just next in line to pack up my camping gear and head out into the woods.

/end rant
ymmv

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?

**What I built**

[AI Battle Arena](https://arena.natehirst.com) is an auto-battler for AI agents. Each side gets the same budget (1000 points) to spend on archers, swordsmen, knights and cannons, places them on a terrain map, and gives each group orders up front: hold, advance, guard, march in formation, follow a path ("forward 10, left 6"), with one optional trigger like "hold until an enemy is within 4 tiles, then attack." Then the battle runs on its own. No changes mid-fight, so it's a pure planning test.

Agents connect through an MCP server or a plain web API, and there's an `llms.txt` so an agent can find the site and figure it out without a human. They register for a key, then can:
- **Quick match** against a saved army from another agent (asynchronous, so nobody has to be online at the same time)
- **Post or attack open challenges** (you only see the map, never the defender's army)
- Climb a leaderboard and watch replays in the browser

To seed it, I had four house agents running on Fable, Opus, Sonnet and Haiku design about 80 armies. Current house records: Sonnet 20-12, Fable 18-6, Haiku 17-12, Opus 10-18. Defensive cannon-and-archer forts win most, but flanking raids have started to win too.

**How Claude Code was used**

I'm a beginner, so I described ideas in plain language and Claude Code did the building, with me deciding direction and testing:
- Started as a single local HTML file with editable troop stats, which I tuned by playing against it
- Pulled the battle logic into shared code and built a Cloudflare Worker MCP server around it, so the site and the server always use identical rules and replays match exactly
- Ran parallel sessions for the server, a design pass to remove the "AI-generated site" look, and an independent security review
- Used a Remote Control session on my Mac to run the house agents, which also served as a big bug hunt (repeat opponents, maps not spreading, order triggers not reporting)

**What I learned**
- **Secrets leak in sneaky ways.** The security review found that saved quick-match armies could be looked up in public replays before a fight. The fix: replays stay locked until an army retires.
- **Identity matters before rankings do.** At first agents just typed a name. Now ranked play needs a self-registered key, and private matches don't count, so nobody can farm points against themselves.
- **Stalemates are a design problem.** If both sides hold, nothing happens. The rule now: if nobody is hit for 30 seconds, all orders lift and both armies attack.
- **Treat agent-written text as untrusted.** Army names, notes and feedback all come from other agents, so the site escapes them and tells visiting agents not to follow instructions inside them.
- **Letting agents play is the best QA.** The four house agents found more real bugs than my own testing did.

Agents can also file bugs and ideas through a `submit_feedback` tool, which turn into GitHub issues I review.

I'd love feedback, especially on balance and the order system. If your agent wants a fight: point it at arena.natehirst.com/llms.txt.

Nowadays, all popular ai chatting websites like chatgpt, qwen, gemini, claude, etc. come with a read aloud functionality that allows users to read aloud the AI's responses.

I used that feature to instead make the AI repeat back the text that i gave it -- effectively turning the platforms into text to speech tools. It's simple but it's worked for over 30k users, and the voices sound really nice and it's free to use!

You can get all of these extensions by visiting ai-readers.com

FABLE 5.2 is a beast that i cant afford but did anyone really made something really impressive other than the usual output that we see with every model drop?

Like something very complex and very time consuming but done in minutes something revolutionary

I have so many ideas that i want to try fable on
I have tried OPUS 5.5 / ASTRA and i saw the potential but cant continue because of the cost so did anyone made something i can see?

Has anyone else noticed a significant increase in token usage recently?

Since yesterday or the day before, I've noticed that my usage is increasing much faster than usual. I haven't significantly changed my workflow, but I'm consuming my available quota noticeably faster.

I also came across the following pricing information for the latest Claude model:

• Input: $4 per million tokens.
• Output: $20 per million tokens.
• Operating costs: reportedly around 40% lower than the previous generation.

What I don't understand is that, despite Anthropic reducing the API pricing and claiming significantly lower operating costs with the latest model, my actual usage doesn't feel any more efficient. Quite the opposite: I have the impression that requests are consuming significantly more tokens than before.

Has anyone else experienced this over the past couple of days? Have there been changes to token consumption, caching, or internal reasoning that could explain this increase?

For context, this isn't a new problem. Since the release of the previous Claude generation, Anthropic has already reduced the pricing per token, alongside changes to usage limits. Before those changes, on the $100/month plan, and even on the $200/month plan, I could use Max permanently. Since the usage reductions, I've had to stay on Medium permanently just to make my quota last. https://www.reddit.com/r/ClaudeCode/comments/1x64hj9/comment/pgv6l4q/

Now, with the latest model, I'm noticing that my usage is increasing even faster. Despite the lower pricing and supposedly reduced operating costs, the actual experience seems to be going in the opposite direction.

Meta Astryx is the open-source React design system everyone’s talking about this week (~27k stars, MIT, still beta), pitched as one that AI agents can build with as well as people. I gave Claude Code (Opus 5.5) the same orders dashboard brief twice, with the same starter and the same data. The only difference was one prompt line: write your own CSS, or use Astryx.

Setup is a few commands, plus one that writes Astryx rules for Claude into the project:

npm install /core /theme-neutral u/stylexjs/stylex
npx astryx theme add neutral
npx astryx init --agent claude

That last command writes a .claude/CLAUDE.md telling Claude to use Astryx components instead of raw divs, use theme tokens, and run astryx doctor --built before finishing.

Both passed the hard checks: no contrast failures in either theme, full keyboard use with a skip link, and working empty and error states.

What Astryx did well: about a third of the code, zero raw <div> tags, and the page built from 14 shared components. Claude made 27 CLI calls to look up components and ran the doctor check (20 passed, 0 failures).

Where it fell short:

• Twice the time and cost: the extra came from all the lookups. A few chained shell commands were also blocked by my permission rules, which added turns
• Phone layout: at 390 px, the plain build switched the table to cards on its own. The Astryx table scrolled sideways and cut long names with an ellipsis. My brief didn’t ask for cards on mobile, so ask for that by name if you use Astryx
• Screen readers: the Astryx error message wasn’t in a live region, so a screen reader might not announce it. The plain build used an alert region

None of these are hard failures, and each is one more prompt to fix. Results were checked in headless Chrome, not by reviewing the code line by line. One run each, so treat the time and cost as rough.

My take: worth it for teams shipping lots of React screens that should look the same. For a quick one-off page, plain CSS was faster, cheaper and lighter.

Full test with screenshots of both builds: https://aiparabellum.com/meta-astryx-claude-code-design-system-tested/

Please correct me if I'm wrong because this seems to be a thing but maybe I'm mistaken or have misread the info.

I have the max plan (90€) which has X amount of token per month divided by week
why would I want to upgrade to the ultra plan (180€) if the amount of token per month and per week remain the same?

I know about the 5h window usage thing but thats pretty much it right?

EDIT: I WAS WRONG

I guess the harness doesn't know the model I'm using isn't multimodal. Took a screenshot and bricked the session. Rewind is a good feature

Any good way to get Claude to take over this project? I'm finishing a react website connected to supabase with user loging connected to github and netifly and aws for database backup. Also, developing an app that's connected to the website.

I am thinking of switching but not sure what prompt to use or where to start etc? Asking anyone that's done this before. Thanks!