Hi all,

No layoff talk brewing at my company. Yet.

But I’m definitely at the point where the model is so good, I crush anything that is assigned to me in 1-2 hours. I’m having a hard time filling an 8 hour workday.

All tech debt : gone. I solved it.

I ask for more work: “we’re still gathering requirements.”

I’m worried that it is only a matter of time before senior leadership notices that there isn’t enough work to feed the amount of devs we have.

I feel like Opus 5.5 was another inflection point. Previously, I had to build sophisticated orchestration, baby sit models, and curate context. And that took a lot of my time. This model needs very little of that.

Maybe it is just me, but definitely feels like I'm hitting my limits a lot faster.

And I'm on the 20X plan. Never was an issue until past 48 hours.

I recently taught a buddy of mine to use claude code, and he’s starting out on the $20/mo.

After months of using fable for 4-10 hours a day here’s what I noticed.

1) It’s still opus. It’s hard to describe but the feeling when talking to it is still a generation behind Fable. It gets hung up on small things and keeps bringing it up if you dont answer. It’s less likely to preempt solutions. It’s more verbose. And overall it just reminds me of the slog of developing with opus 4.7-4.8

2) It’s still very capable and you can definitely get it to do very complex and long horizon tasks, much closer to fable than the 4.x generations. (I had it help me get a website up and running using firebase+github+vercel + setting up DNS)

3) If anthropic charged $500 for fable i’d still pay for it. The frictionlessness of fable and it’s ability to be in lock step with you as you develop bigger and better products/integrations/modalities is simply unbeatable.

Has anyone gone from fable to full time opus and been happy with the “downgrade”. After my buddy saw what opus could do he was astonished that there could be a model that was worth $80/mo more.

New Claude Code UI update. What do you guys think?

I really feel like this is kinda more complicated than it needs to be. I loved it before where you finally could select model effort with the slider, see usage and context (with the stacked bar graph showing what is messages, mcp etc) in one go/ area. I feel like this is a step back.

Is there a way to customise it to go back or is that something only anthropic can do?

I am loving that handoffs can happen when context gets full and you just click a button and claude spins up a nested session under main session - saves so much time rather than manual handoffs i was doing before. Claude even suggests when to move it to new session

apologies if this has always been there and I just discovered it but I am pretty sure this a new feature on the desktop release

In 1967 Ted Nelson described stretchtext: text that grows where you want more and shrinks back where you don't. It stayed a quaint idea because writing every level of fidelity by hand is just tediously hard. Text is generative now, so Claude can just write it for us for free.

I've always tried to implement this idea with LLM in various ways. Claude Code Mods finally proivded a platform to share.

cc-stretch is a Claude Code plugin. It cuts Claude's reply by 83% so you read much less, yet still have the option to expand / shrink on demand. The plugin also tells Claude which parts you opened, so it doesn't assume you read the rest.

Install in a Claude Code session:

/plugin install cc-stretch --marketplace pro-vi/cc-stretch
/tui fullscreen

Repo: https://github.com/pro-vi/cc-stretch (MIT)

I can confirm that the issue seems to have been resolved today. However, we've already burned through a significant portion of our weekly quota because of it.

Personally, I have four days left until my quota resets, with only 30% remaining. Most people in the original thread reported similar usage issues, although there were some differences from one user to another.

Even if usage is back to normal now, the damage has already been done. Those of us who experienced unusually high usage are still left with depleted quotas for the rest of the week.

Anthropic shouldn't just fix the issue and leave it at that. Given the impact on users, I think they should make another gesture to compensate those affected.

Original discussion: https://www.reddit.com/r/ClaudeCode/comments/1x64hj9/comment/pgx8ai2/

I just came across someone with practically no coding experience releasing an open-source password manager called KAPEVault.

Project: https://kapevault.brewedops.cloud

And we're not talking about some basic tutorial project. This is an actual downloadable Windows and Android application being publicly distributed for storing passwords, 2FA codes, API keys, government IDs, and other sensitive information.

I'm a software engineer, and I actively use AI coding tools myself. I think they're incredible. But seriously, of all the things you could build with little to no programming experience, why the fuck would you choose a password manager?

To give credit where it's due, the project is open source, has a documented threat model, automated tests, and a self-conducted security review. But the repository also explicitly acknowledges that it hasn't undergone a third-party security audit.

That's a pretty important distinction when you're asking people to trust your software with practically their entire digital identity.

Using AES-256-GCM and scrypt doesn't automatically make a password manager secure. Neither does having a polished interface, passing automated tests, or getting an AI to review its own output.

Security isn't just about choosing the right encryption algorithms. It's about understanding the entire attack surface, handling secrets properly, identifying edge cases, and knowing what can go wrong even when everything appears to work.

I'm not saying this particular project is insecure. I haven't performed a security audit, and that would be an irresponsible claim.

My concern is the growing confidence with which people are releasing security-critical software they may not fully understand.

There's absolutely nothing wrong with beginners experimenting, learning, and open-sourcing their projects. That's how people improve. But building something for educational purposes and distributing something that real users might entrust with their banking credentials are two completely different levels of responsibility.

AI has made it ridiculously easy to produce working software. Unfortunately, it has also made it ridiculously easy to mistake a working application for a secure one.

You can outsource writing code to an AI. You can't outsource accountability when something goes horribly wrong.

At what point should we start taking this seriously?

been hitting limits less since i changed a few habits, sharing in case it helps someone:

1. ask it to read files in line ranges, not the whole file. a big read stays in the context for the rest of the session and you pay for it every turn
2. send wide searches / research to a subagent. only the conclusion comes back to the main thread instead of 20 file dumps
3. put these as rules in CLAUDE.md, otherwise it slowly goes back to old habits
4. start a fresh session for a new task instead of dragging a long one along
5. when a session gets long, ask it to summarize the state into a file and continue from there

anything else that worked for you?

Hi, I'm from Korea and my english is not good, so I write this with translator help. sorry if some sentence is weird.I'm making Spearhead alone. It's WW2 eastern front RTS in Unity, and you can press H and ride any tank and drive it yourself. Almost all code is written by Claude Code. I started end of May and now it's about 400k lines C#. Honestly I can't read all of it, so my job is play the build and tell Claude what is wrong.

How I use it: I send many complaints at once with screenshots. Main session find where the problem is and give each one to sub agent. Each agent can edit only its own files so they don't break each other. After that it compile everything and make checklist image on my desktop, then I test.

Today example. The tank riders (desant) jump off pose was strange, so I put 2 old photos of soviet soldiers jumping from T-34 on my desktop and said "look this, they must jump like this or they get hurt". It fixed the seat position on the tank and made the jump pose from the photos. What I learned is memory file with rules is more important than good prompt (like never commit if I don't say, and compile ok is not fixed). Also 1 agent for 1 group of files, before this agents broke each other work a lot. And don't send message to agent while it's working, it get lost often.

voice, music and some store art is AI placeholder now, 3D models are bought assets. steam page in comment.

Almost got the hat trick!

Been a good boy all week, rationing my tokens carefully, clearing and compacting with care, and ended up 2 hours away from reset time with like 60% weekly and 45% Fable usage....

So f*ck it, Fable on Max, do a full audit of the control panel, look for bugs, vulnerabilities, performance bottlenecks, and suggest improvements... And 30 mins later we're here, "with room to spare", sure :D

I went through the claude code docs this morning instead of the changelog and found a few things about why long sessions eat your limit that I hadnt seen posted anywhere.

the main one.. your prompt cache lives for an hour on a subscription while youre inside your plan usage. the moment you go past that limit and start drawing on usage credits, the main conversation drops to a five minute ttl. same session, same work, the gap you can leave before a cold reprocess just got 12x shorter. on an api key or a cloud provider its five minutes by default from the start.

everything that isnt your main conversation already gets five minutes regardless. subagents and workflows and compaction and session titles. so a subagent you come back to after ten minutes reprocesses from scratch even on a max plan tbh.

the fix is prob one setting. promptCacheTtl set to 1h, or the CLAUDE_CODE_PROMPT_CACHE_TTL env var. subagentPromptCacheTtl covers the rest. needs v2.1.242 or newer. api key users can set it too.

two other things I didnt know. switching models mid session reads your entire history with zero cache hits. if you run opusplan then every toggle in and out of plan mode counts as a model switch, so bouncing between planning and building rebuilds the cache each time. agent teams also run roughly 7x the tokens of a normal session when teammates sit in plan mode, which the docs state as a plain number.

run /usage and look for the Prompt cache (main) line if you want your own hit rate. needs v2.1.251. on v2.1.260 and up it also names the likely cause of your last miss.

hope this helps.

The difference is so striking, my context usage suddenly hits 80%+ on a single prompt (20x plan), tasks are taking at least 2x longer than they did before AND producing far more mistakes.

Several mistakes it already made months back, which I set up rules to prevent from happening again, are now happening again for the first time since I made those rules.

This is the worst state I've ever seen Claude code in since I started using it. Curious if anyone else is experiencing the same to determine how wide spread this is.

I use Claude Code Sonnet 5.5 with Haiku 5.5 subagents

I use Codex Sol 6.1 with Luna 6 subagents.

I constantly hit the 5 hour limit with Codex.

I haven't hitted the limits even once with Claude.

The rumors are no longer rumors, Claude gives much more value. And I personally found the results much better than in Codex.

You ask for an exploded view of a real thing (a lock, a Rubik's cube, WinRAR, React). The agent looks up the numbers and tags each one SPEC / MEASURED / DERIVED / ESTIMATED with its source. A gate script compares the model with what is published, and if it disagrees, nothing renders.

Examples of what the gate checks: a pin tumbler lock must put all five splits on the shear line with the right key; Enigma must reproduce the published test vector (AAAAA becomes BDZGO); a model of React's rules must predict the 1 of 8 DOM nodes the real React 18.3.1 touches.

The part that worked for me as a skill author: a gate the agent cannot argue with, and testing the skill with fresh sessions that know nothing about it, then fixing everything they tripped over.

Output is a 30 s film with sound, an interactive viewer and an STL/GLB. Built with Claude Code (three.js in a headless browser + ffmpeg).

Limits: films need a GPU, I have not tried macOS, and the gate checks the model against the published number, not against reality.

Repo (MIT): https://github.com/DiegoLopez0208/mechanism

Films and viewers: https://diegolopez0208.github.io/mechanism/

Install: /plugin install mechanism --marketplace DiegoLopez0208/mechanism

Which object should it model next?

3 weeks ago (after the usage correction) I posted that 4 five hour sessions consumed 100% of my weekly Fable use (20x).

Now 2 five hour session consumes 100% of my weekly Fable.

Have I missed communication regarding a change in usage?

I noticed that the last three days I am way more likely to hit my session limits, and my weekly limit is getting eaten quicker too.

This could very easily be my behaviour, ie I think I am trusting the model more so letting it do bigger tasks in fewer steps, but I wanted ask if anyone else noticed the same thing this week.

Is Claude asking questions like this new? I haven't noticed this before.

I am honestly not a big fan because it is always asking me to make a decision, but it gives me ZERO context on what it has done.

How can I make a decision if I don't know what is being proposed?

Tonight I went to write some code as per usual and I tend to be very pedantic, so I review and adjust a lot. I was re-implementing an older app in go so I had left claude to copy over some of the logic. Once it was done I went to review and the whole codebase was an absolute MESS.

This was one of the most brutal examples that literally had me questioning whether I had written a single line of go code in my life...

func (h *Handler) registerCars(g huma.API) {
    huma.Register(g, get("/cars/{id}", "getCar", "Cars", "Car details"),
        func(ctx context.Context, in *IDPath) (*Body[store.CarDetail], error) {
            car, err := h.store.Car(ctx, in.ID)
            return result(ctx, car, err)
        })

    create := op(http.MethodPost, "/cars", "createCar", "Cars", "Register a car and its client")
    create.DefaultStatus = http.StatusCreated
    create.Errors = []int{http.StatusBadRequest, http.StatusConflict}
    huma.Register(g, create, func(ctx context.Context, in *CreateCarInput) (*Body[Created], error) {
        b := in.Body
        id, err := h.store.CreateCar(ctx, store.NewCar{
            RegistrationNumber: strings.ToUpper(strings.TrimSpace(b.RegistrationNumber)),
            // ...
            CreatedBy: currentUser(ctx).ID,
        })
        return result(ctx, Created{ID: id}, err)
    })
}

This is a slightly truncated version of the code but this is genuinely atrocious by my standards.

Once rewritten by me my implementation now looks like this:

func registerCarRoutes(group huma.API, carHandler *handlers.CarHandler) {
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars", "searchCars", "Cars", "Search cars", http.StatusOK), carHandler.SearchCars)
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars/recent", "listRecentCars", "Cars", "Recently repaired cars", http.StatusOK), carHandler.ListRecentCars)
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars/{id}", "getCar", "Cars", "Car details", http.StatusOK), carHandler.GetCar)
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars/{id}/repairs", "listCarRepairs", "Cars", "Repairs of a car", http.StatusOK), carHandler.ListCarRepairs)
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars/{id}/images", "listCarImages", "Cars", "Images of a car", http.StatusOK), carHandler.ListCarImages)
    huma.Register(group, helpers.Huma.Operation(http.MethodGet, "/cars/{id}/images/{imageId}", "getCarImage", "Cars", "Car image binary", http.StatusOK), carHandler.GetCarImage)


    huma.Register(group, helpers.Huma.Operation(http.MethodPost, "/cars", "createCar", "Cars", "Register a car and its client", http.StatusCreated, http.StatusBadRequest, http.StatusConflict), carHandler.CreateCar)
}

And the handler:

func (handler *CarHandler) GetCar(ctx context.Context, input *GetCarInput) (*GetCarOutput, error) {
    car, err := handler.db.Cars.ByID(ctx, input.ID)
    if err != nil {
        return nil, apierror.FromDBError(ctx, err)
    }
    return &GetCarOutput{Body: car}, nil
}

Now, to me this is a million times more readable and claude actually had references like this in the code. I actually am not sure where it misunderstood me or what happened but that first piece of code just felt like an actual flashbang when I read it...

Is this some A/B test where I got something like Haiku 1.1? Or is this is the standard way other go devs write code and I am just super weird with my structure? Or did I just get INSANELY unlucky??

I'm genuinely trying to figure out if other go devs would find that implementation acceptable and I'm at fault here or if claude really just wrote slop.

(I purposefuly included screenshots and code to get benefits of syntax highlighting and being able to copy code)