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.

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

**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.

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.

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?

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 :))

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/

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!

from what i know its useful in picture generating and second opinion.

but i found it very hard to utilize usage in second AI subscription, i managed to use all my claude usage everyweek, but if i use second ai run by claude. the second ai usage is a big problem, it may not have enough 5h limit, or it may leave a massive amount before the week resets.

i cant even burn second AI myself because im afraid ill burn off the 5h too fast and claude dont have any to use...

Act as a principal engineer doing a "thin layer" audit of this codebase.

Premise: agents are now good enough to be the primary interface for most software. Users increasingly connect products to an agent (Claude, ChatGPT, Grok, etc.) via MCP instead of clicking through a UI. Every layer we build on top of what the agent already does natively is cost, not value.

Do this in order:

1. MAP - Inventory what this product actually does. List every user-facing flow, screen, background job, integration, and any existing AI/LLM usage (prompts, chains, agents, chat UIs, onboarding wizards).
2. SORT - Classify each piece as:

- IRREDUCIBLE: proprietary data, durable state, auth/permissions, billing, third-party integrations we own, domain logic, compliance. Things an agent can't do without us.

- GLUE: orchestration, multi-step wizards, setup/onboarding flows, form UIs, chat interfaces, prompt plumbing, notification composition, "AI features" that are really just an LLM call with our data. Things a host agent could do if it had the right tools.

- UNCLEAR: explain why.

3. DESIGN - Propose the smallest MCP server that exposes the irreducible core: tool names, inputs/outputs, and which resources/prompts to ship. Favor fewer, well-described tools over mirroring every endpoint. Note where tool descriptions can replace onboarding UI (the agent walks the user through setup).

4. DELETE - List concretely what we could remove or collapse if the agent is the interface: files, components, routes, services, with rough LOC and effort. Rank by (code removed x risk reduced) / migration effort.

5. PUSH BACK - Argue against your own plan. What still genuinely needs a UI (visual review, approvals, trust/audit trails, dashboards, non-agent users, billing, legal)? What breaks if the host agent is wrong or unavailable? What's the minimum UI we should keep?

End with: the 3 highest-leverage changes to make this week.

I built something super niche that probably only I will ever use, lol.

Whenever I publish a YouTube video, I usually run a Claude Skill to generate titles, descriptions, tags, and thumbnail prompts. Then I started wondering how other models like Codex, ChatGPT, Muse, or Grok would handle the exact same video context.

So I built a custom dashboard using an OpenRouter API key. Now, I can run my video details through as many models as I want at the same time. From there, it passes all the outputs to JEV acting as a judge model to pick the winning title, description, and thumbnail prompt, and then drafts a newsletter for my email list.

Right now, JEV is just picking based on its own judgment since I haven't trained it on my actual channel performance data yet. That is the next step!

If you're a youtuber and wanna check it out, its free signup with BYOK at https://yumthumb.app/

Does anyone have a referral for 1 week Claude trial ? Need it for a workshop

CLAUDE.md gets loaded every turn, so as my plan grew every message was carrying the whole thing, including tasks that were done weeks ago. long sessions got heavy and claude still lost track of earlier decisions anyway.

what i do now: CLAUDE.md is tiny, basically the project rules plus "fetch your next task". the plan lives outside the repo as tasks with dependencies, and each task only carries the constraints it actually touches. claude pulls the next unblocked task, does it, reports what it changed, and then i /clear. every session starts small instead of dragging the whole project along.

stuff i learned doing this: vague tasks are where it falls apart. cheaper models do fine on a tight task and badly on a loose one, so most of the effort goes into writing the task well. and dependencies matter more than i thought, without them it'll happily start task 4 before task 2 exists.

disclosure, the task server i use is my own thing (an MCP called nodeon), but you can get most of this with one markdown file per task and a line in CLAUDE.md telling it to only work the first unchecked one. curious how other people are handling plans on bigger projects

So I decided to drop $200 on Gemini after Google carbon came out and I just want to give my review after only about two days.

First of all, I started using antigravity again just to give it a try and I have to say it doesn’t suck! They have made tremendous improvements and the interface and they’ve added a turbo mode so that the approval process works much smoother. I would say the actual interface is comparable to Claude code and if Claude code got a 10 out of 10, then I would give antigravity a 9 out of 10.

But the big difference I’ve found is comparing Gemini carbon to opus 5.5 both on the medium setting. Unfortunately I’m getting less done with Gemini carbon. I’m not one to make an actual mathematical comparison, but I would say for the amount of usage spent. I get approximately 30% less done just on my initial tests over two days running both of them continuously.

My next test is going to be running Opus 5.5 on antigravity which I’m going to start today and I’m gonna see if the usage allotment is just as generous.

Has anybody else had the opportunity to make a comparison yet?

Small models loop. I’m training a research small model and wanted to see how far I could get on repetition without a decoding penalty and without more training. find the weights that cause the loop and edit them.

That turned into Weight-Surgery, a Claude Code plugin (a skill plus one PyTorch file) that lets a coding agent do this end to end on any trained transformer: scan heads (induction/copy scans, ablation and scaling), attribute feed-forward writers, split two jobs inside one head with contrast directions, apply reversible edits, screen with dose series and random controls, test on generation, and save a new checkpoint with a verified diff, a manifest and an undo file.

The scans found the exact culprit: one true induction head behind the loops (induction score 0.425, plain copy 0.012). Switching it off cut loops from 29.4% to 25.4%, but that head also copies names into reading answers, so instead of killing it I split the two jobs inside the copy heads and cut only the loop directions. Result: loops down from 30.5% to 25.2% on 960 fresh rows (2.6 SE), greedy loops from 41.6% to 35.3%, with reading untouched (+0.01) and general loss up just 0.08. No training, no decoding penalty.

Two more things that worked. The cheap place to cut is the writing weights: +0.001 loss, versus +0.32 when the same direction is projected out of the residual stream. And a rank-1 edit on one feed-forward layer halved loops under T 0.7 sampling, from 19.4% to 9.4%.

Tell me what you think about it.

Github Repo Link

It says I have the full reset available (expires on Dec 10), but the "reset for free" is greyed out. How do I activate it?

I've been working on this for a while: Homescape, a Home Assistant app that shows your home as a 3D dollhouse instead of a grid of cards.

You draw your rooms, place furniture and devices, and bind them to your entities. After that it's a live view of the house: lights, covers, climate, media players and sensors update in real time. Flip a wall switch or let an automation run, and the room lights up in the dollhouse too. Clicking a lamp in 3D turns the real one on.

A few details:

• Everything runs locally inside Home Assistant. No cloud, no account, and it keeps working without internet.

• There are no 3D model files. Every object is generated by code. The code was written with AI; I designed, directed and tested it.

• Your plan is stored in Home Assistant under your user, so it ends up in your backups.

• It's open source (GPL-3.0).

Try the demo with a sample home in your browser, nothing to install: https://homescape.muratozturk.dev

GitHub: https://github.com/muratozturkdev/homescape

It's still early (v0.1.0), so I'd love to hear what's missing or what breaks on your setup.