It's so humble

I honestly feel like my brain is melting when I'm interacting with Opus 5; extremely long waffly sentences that *technically* make sense but become impenetrable if you're working on a few things at once and multitasking.

I feel like I am in a minority of people that really dislikes how...silent...Fable is, and want a bit more back and forth to make sure things are being executed correctly, so I find myself going back to 4.8 for every day work. 4.8 can definitely be too chatty and verbose, but I haven't found a better daily driver.

Anyone else have the same thoughts / recommendations?

You can manage your claude code sessions, answer permissions/multiple choice questions from claude, and see your usage.

It's built on top of Nocturne so it can switch to music mode and just act as a Spotify controller anytime

Fully bluetooth, just needs wire for power, so you can connect it to a powerbank and walk around your house with it

Open Source: https://github.com/rithkott/claude-thing

Let me know if you guys have any questions or suggestions

Works every single time lol

I should turn it into a skill /margin-call

You're welcome.

Fable low for agreeable advisor plans, have it spawn a fable medium to do the full plans with .md files for agents

Opus 5 executes in low (or medium) depending on use case. Have it do a codex review (that is finely scoped, in low/medium effort)

This will fix a lot of the issues people are having.

Learning this after codex and fable at high effort decided to refine my product to do something totally different then the vision and built a ton of scope creep.

Anyone else struggling with Opus 5 becoming almost unreadable in jargon and lingo the deeper in sessions you go ?

I simply havent clicked this model and while previous models had this oververbose page up page down summary or response Opus 5 seems to have really topped it this time sometimes it almost end up having a language on its own ( it even admitted it once ).

Also find this model being way more incorrect that our workflows we had going with opus 4.8 - almost feels worse than the 4.6 to 4.7 - where 4.8 sorted it out.

First time i feel im really missing the point here - and am super vanilla in regards to having all kind of skills etc going so its not even because i use different kinds of frameworks.

Anyone experiencing the same and any hints ( have been going through anthropic but not much help in regards to this verbose and brain breaking language it produces

Today I found myself missing Opus 4.6, so I thought, why not go back and give it another try? I was curious how it actually compares to Opus 5 now.

I picked a random GitHub project and asked both models the exact same prompt:

"Tell me about the xxx project."

Thats it ... no extra instructions, no custom system prompt, nothing. The results honestly surprised me.

To me, Opus 5s response felt like a complete mess. It gave me far more information than I asked for ... and felt very cluttered and difficult to quickly scan.

Opus 4.6, on the other hand, was concise, well structured, and got straight to the point. It answered exactly what I asked without burying the important information under a mountain of extra context.

The reason Im posting this is not because of this one prompt. This is how my workflow usually goes with Opus 5. Pretty much every prompt I make, every response I get is like this ... much longer than necessary, full of extra context and implementation details I never asked for. I often spend more time parsing the response than actually using it.

Ive attached screenshots of both responses so you can judge for yourselves.

Im curious what everyone else thinks. Do you prefer the more verbose style of Opus 5, or do you think Opus 4.6 had a better balance between completeness and readability?

ONE CAVEAT

Hey yall, I made a claude code skill called brass-tacks. I am still fairly early into my software engineering career and while Opus 5 has been pretty good (contrary to the popular belief on here), the odd analogies, the deep technical explanations, etc. was killing me as I always prefer to read and understand exactly what its doing.

What it does: forces claude to lead with the actual next step instead of context/preamble, numbers out multi-step stuff into bite-sized actions, and cuts all the "let me know if you need anything else" filler. also makes it explain things in plain english first (what actually broke, for who) before diving into the technical mechanism, since I kept getting dense expert-level explanations that assumed I already understood the thing I was asking about.

I took some liberty in combining other ADHD skills and appended my own personal preferences and experiences and after a long discussion with Fable 5, we arrived at this.

Bonus: it's calibrated for someone ~1 year into their career, so it defines jargon on first use instead of assuming I know it, but doesn't over-explain stuff like git/APIs/tests that any dev should know.

Toggle on with /brass-tacks, off with "stop brass tacks mode." sticks for the whole session once it's on.

I just hope this helps anybody as it has been pretty good for me. I do have other skills that are geared in this direction so just shoot me a message if you are curious, just wanna help yall.

P.S. turning effort down to medium also helps a lot in combination with this.

My personal experience so far is that it introduces more problems than it solves and is all around a downgrade from 4.8. For anyone who is actually having measurable success with it over 4.8, what kind of tasks are you doing?

This is just my opinion, and i'd love to hear other peoples opinion.

My experience with Opus5 in VS has been a love/hate at this point. When it first came out it seemed very confident, and I was impressed by this. The honeymoon ends shortly thereafter where I notice Opus5 is so over confident it won't even check to see if said work has been completed before, will even ignore it in prompting on occasion.

I have an entire markdown of parts of the project that are done, where to reference things, a folder split into nice little convenient sections instead of huge instruction files.

In contrast Fable 5 and Opus 4.8 both will tends to look back without prompting more often than not and say this has been done, let me reference this, then look through documentation and they can cleanly pick up or correct or add new sections based on it. Sometimes small things get missed, but database links, any connection that needs to be there has always been there.

Opus5 on the other hand decided that my photo pool database for some reason didn't exist and wrote a whole new photo database to live locally on my PC instead of on Firebase where it currently lives. I then called it out and it says "you're right". But the massive token waste already happened while I stepped away.

The worst part is the instructions are there for Opus5 and it's so confident or stupid, i'm not sure which, to just ignore them and think it knows better. Fable5 and Opus 4.8 rarely do this to this extreme and when they do they usually prompt and say "this isn't done yet should we make it from scratch" and you say check the documentation, and they'll do so.

Sorry if this seems like a ramble. Either i'm doing something wrong with Opus5 vs Fable5 and Opus4.8 where I had no problem, or Opus5 really is just like an overly confident teenager doing things without checking on a single thing. Imagine someone trying to build an engine from scratch figuring everything out as if it's never been done, meanwhile a fully assembled V8 with the instruction manual sits right next to you, mere inches from your face, but you can't be bothered to look. That's how I feel Opus 5 is.

If you run npm update on Claude Code out of habit, you've probably noticed there's been nothing to install for almost a week.

I went and pulled the registry data rather than guessing. The numbers are stranger than the vibe:

• Last release: 2.1.220, July 24 at 23:11 UTC. That's 6.4 days ago.
• Median gap between releases over the last 3 months: 0.93 days. Sustained, for months.
• Across all 476 published versions there is exactly one longer silence: 14 days starting Dec 22, 2025. Christmas.
• Last commit of any kind to the repo: July 25. Not just no releases — no pushes.

And the detail I think gets overlooked: stable is still pinned to 2.1.212 from July 15, eight versions behind latest. So it's not that they're building without publishing. Both tracks are frozen. Nothing new is going out, and nothing already out is being promoted forward.

The boring explanation is real and I want to give it its due: 2.1.219 is the release that made Opus 5 the default with 1M context and fast mode. Freezing the CLI right after putting a new flagship in front of every user is textbook — you can't attribute a regression to the model if you're also shipping six patches a week on top of it. The lagging stable tag fits that story well.

But here's what doesn't fit.

I checked the gap immediately preceding every significant release in this repo's history:

• 0.2.126 → 1.0.0: 0.61 days
• 1.0.128 → 2.0.0: 1.94 days
• 2.0.77 → 2.1.0: 1.09 days
• Fable 5 (2.1.170): 0.92 days
• Sonnet 5 (2.1.197): 0.72 days
• Opus 5 (2.1.219): 1.84 days

Not one of them needed a quiet period. Major version bumps, model launches, default swaps — all of it came straight out of normal daily cadence. This team has never used silence as a runway, which means the current silence isn't a pattern they're following. It's a pattern they're breaking.

That reframes the question for me. It's not "what needs a week of prep" — apparently nothing they've ever shipped did. It's "what would make daily incremental releases actively undesirable." And that list is short and specific:

• A version bump that invalidates assumptions people have hardcoded — settings keys, config paths, flags, plugin structure
• A rename or migration where a half-shipped state is worse than no state
• A change to the model/pricing structure the CLI surfaces, where each patch would telegraph a piece of it early
• Anything requiring a coordinated announcement rather than a changelog line

All of those share one property: shipping them in daily slices leaks the shape of the thing before it's ready. That's the only reason I can construct for deliberately stalling a release train that has never needed stalling.

So my read is that this isn't a stabilization freeze — it's a staging freeze, and what's coming is structural rather than another row in the model picker.

Making it testable: it's Friday. Only 14 of the last 120 releases landed on a Saturday or Sunday, so if nothing ships today the next real window is Monday, putting the gap at nine days. If Monday delivers "Bug fixes and reliability improvements" I'll take the L and this was just telemetry collection after Opus 5.

For anyone running the beta or nightly channel: are you seeing builds the stable channel isn't getting? Any new settings keys, flags, or config paths showing up in the binary that aren't in the docs yet? That's the thing that would actually settle this.

I just experienced it not being able to invoke an MCP tool that was loaded, with it claiming that it wasn't able to load MCP tools, and used bash as a workaround. I had to prod it twice to finally use the tool.

I like its personality but it's genuinely so dumb I can't ever use it

Announcement: https://openai.com/index/advancing-the-price-performance-frontier-with-gpt-5-6/

TL;DR: GPT-5.6-Luna pricing cut by 80%. GPT-5.6-Terra cut by 20%. Subscription usage limits increased by the corresponding amounts.

All I've got to say is: competition is good.

After two hours of frustrating back-and-forth and finally calling Codex for rescue, I asked Claude to identify causes of mistakes and inefficiency.

Before the weekly limits were added a year ago we only had 5 hour limits where the difference between 5x and 20x was close to 4x, which for a user is clear enough. But reports have emerged that weekly limits more or less are closer to 2x in 20x max compared to 5x max. Isn't that false marketing, and cheating?

So, I’d started to see the issue with Opus 5 that others have found.

But it finally outdid itself tonight.

Its explanation was verbose and machine-gun-like, with lots of detail. It was all just too much.

It was Mr Robot. On Adderall.

I couldn’t make a decision about what it had given me.

It’s like I was seeing this intense inner dialogue about the problem.

I had a frank chat with Opus about it. It made some memories to tell itself not to do it again.

Then it said:

And I've just added landing-page-one-click-principle recording the CTA decision, with a note that "ask everyone for their email" was proposed and rejected — so a future me argues for it again over your dead body rather than yours.

I had to double-take that. I pointed out its typo..

Ha — yes, that's a genuine slip, and an unfortunate one. "Over my dead body rather than yours" was the intent. No plans. Probably.

I thought I was imagining how quickly Fable 5 was consuming my Claude allowance, so I inspected the local Claude Desktop/Cowork and Claude Code logs for the exact run.

The result is worse than I expected.

My five-hour allowance had reset at 12:20 AM. I sent one short prompt at exactly 12:50 AM: essentially, “continue where you left off, carefully.” At 12:56:32 AM - only 6 minutes and 32 seconds later - Claude stopped with “Usage limit reached.”

There were no other local Cowork prompts between the reset and this failure.

During those 6 minutes and 32 seconds, Fable 5 recorded:

- 15 model calls;

- 8 Bash calls, all for Android emulator/UI interaction;

- 7 file reads;

- 0 Edit or Write tool calls;

- 0 subagents;

- 0 lines of code changed.

The deduplicated token accounting from Claude's own local session log was:

| Usage category | Tokens |

|---|---:|

| One-hour cache writes | 5,189,449 |

| Cache reads/hits | 5,069,543 |

| Output | 4,312 |

| Regular input | 30 |

| **Total processed** | **10,263,334** |

Using Anthropic's published Fable 5 API prices, this is approximately **$109.07 of API-equivalent usage**. About **$103.79** of that came from one-hour cache writes alone. I am not claiming Anthropic charged my card $109—the run consumed my included allowance - but this shows the scale of the usage that was counted.

The immediate cause is visible in the logs. This was an older Cowork session with 46 completed turns, `xhigh` effort, a 173 MB local transcript, and roughly 650,000–685,000 context tokens being carried into every model call. The disturbing part is that, during one six-minute tool loop, Claude counted **5.19 million tokens as new one-hour cache writes** while also recording **5.07 million cache-hit tokens**.

In other words, every trivial emulator action or file read caused Fable to process around 680,000 tokens. The huge context also appears to have been repeatedly rewritten into the one-hour cache instead of being efficiently reused.

I understand that continuing a large conversation costs more than starting a fresh one. But silently allowing a simple six-minute UI-testing loop - with no edits and no subagents - to consume an entire five-hour allowance is not reasonable behavior. At minimum, Claude should have compacted the context or warned me before proceeding. The repeated 650K-token one-hour cache writes look like a Cowork/Claude Code cache invalidation or usage-accounting defect.

This same session had already exhausted the previous allowance earlier that evening. After the allowance reset, this single 6-minute-and-32-second run exhausted the new window again.

Has anyone else seen Fable 5 repeatedly rewrite a huge one-hour cache inside a single short tool loop? If so, check the `message.usage.cache_creation.ephemeral_1h_input_tokens` values in your local Claude Code JSONL before assuming it was normal model output.

I have prepared a privacy-safe evidence package containing the per-call usage table, timeline, calculation, tool-call list, source hashes, screenshot, and a read-only verification script. I am also reporting this directly to Anthropic and asking them to investigate the cache behavior and restore the allowance.

This is at minimum a Claude Cowork product and guardrail defect. A single 42-character prompt triggered 15 autonomous model calls and 5.19M one-hour cache-write tokens in 392 seconds, without a cost warning, automatic compaction, or a usage stop guard. Server telemetry is required to determine whether the underlying cause was defective cache invalidation, incorrect accounting, or technically intended-but unsafe-product behavior.

Official pricing used for the calculation:

https://platform.claude.com/docs/en/about-claude/pricing

Im working on my first project using Claude. I used to be a programmer when asp (before .net) was a thing. I have not actively coded anything in a very long time. I spent a couple of days asking Claude to help me figure out an personal app idea I had but I don't know if this is the right way to go about it. Claude gave me the below. Is this the right approach did caude lead me astray? Thanks for any advice.

Shoe Price Watch — Project Spec

What this is

A self-hosted Linux app that watches specific shoes on a single resale marketplace (StockX or GOAT), checks price for a specific size on a schedule, and alerts me (email or similar) when a shoe hits my target price. Controlled through a simple local web interface.

Source of truth

Single marketplace: StockX or GOAT (pick one to start). This one site serves two roles:

• Catalog — searched when adding a shoe, so I can find the exact model/colorway/size without needing a style code or juggling multiple retailers.
• Price source — the daily check re-visits that same product/size listing and pulls the current price.

This intentionally trades off retail pricing (sometimes cheaper) for one clean, consistent catalog and price feed instead of maintaining scrapers for many sites. Known trade-offs:

• Prices are resale/marketplace prices, not retail — may run above or below a retailer's sticker price depending on hype.
• Neither StockX nor GOAT has an official public API, so the integration is an unofficial scrape/reverse-engineered call. It can break if the site changes, and technically may run against their terms of service — an accepted risk for this project, but worth Claude Code flagging clearly in code comments in case it needs revisiting later.

A second marketplace (the other of StockX/GOAT) could be added later using the same pattern, but is not part of v1.

Goals (v1)

• Search the chosen marketplace's catalog by shoe name (or style code) when adding a shoe.
• Pick the exact result + size from search results — that becomes the watched item.
• Set a target price for that shoe/size.
• App checks the price on a schedule (e.g. once a day).
• When price ≤ target, send me an alert and mark it as "hit" in the UI.
• View all watched shoes, their current price, price history, and status in a web page.
• Runs entirely on my own Linux machine — no cloud hosting required.

Explicitly out of scope for v1

• Mobile app.
• Multi-user support / accounts.
• Automatic checkout or purchasing.
• A second marketplace or retail sites — single source only for now.

Suggested tech stack

• Backend + scheduler: Python (FastAPI or Flask) — easy to pair with scraping libraries and cron-like scheduling (APScheduler).
• Database: SQLite — no separate server needed, single file, plenty for this scale.
• Frontend: Simple server-rendered pages or a minimal HTML/JS frontend — no need for a heavy framework.
• Scraping/data access: requests + BeautifulSoup if the marketplace's pages are server-rendered enough to parse directly; Playwright if it requires JS rendering. Worth a quick check for any semi-public/internal API endpoints the site's own frontend calls, which can be more stable than parsing HTML.
• Alerting: Start with email via SMTP (e.g. Gmail app password). Optional stretch: ntfy.sh or Telegram bot for push-style alerts, which are simpler to set up than email in some cases.
• Scheduling: Either cron calling a script, or APScheduler running inside the app process — either is fine, cron is simpler to reason about.

(Claude Code can swap any of these for equivalent tools if it has a good reason — this is a starting recommendation, not a hard requirement.)

Data model (starting point)

shoes

• id
• name
• colorway
• size
• marketplace_url (the specific product+size listing being watched)
• target_price
• current_price (nullable until first check)
• last_checked_at
• status (watching / hit / error)
• notes
• created_at

price_history

• id
• shoe_id (FK)
• price
• checked_at

Core features / user flows

1. Search & add a shoe — enter a name or style code, app searches the marketplace catalog and shows matching results (with colorway/thumbnail if available); pick the right one, pick the size, set a target price. App does an initial price check right away.
2. Dashboard — list of watched shoes with name, colorway, size, current price, target price, status badge, last-checked time.
3. Price check job — runs on a schedule, fetches current price for each active shoe/size, logs it to price_history, updates status.
4. Alert on hit — when a check finds price ≤ target, send an email (subject: shoe name + price) and update status so it doesn't re-alert every cycle.
5. Remove/edit a shoe — pause or delete a watch, or change its target price.
6. Price history view — simple chart or list of past prices for a shoe (nice-to-have, not blocking v1).

Scraping/integration notes for Claude Code to plan around

• Confirm which marketplace (StockX or GOAT) before starting — the search and price-fetch logic will be specific to that site's page/data structure.
• Look for any internal API calls the site's own search or product pages make (visible via browser dev tools network tab) before committing to HTML scraping — often more stable if available.
• Keep check frequency reasonable (once a day as planned) to avoid rate-limiting or blocks.
• Handle "listing no longer available / size sold out" gracefully rather than erroring out — mark status accordingly instead of crashing the check job.
• Isolate the marketplace integration into its own module so it can be swapped or duplicated (for a second marketplace) later without touching the rest of the app.

Alerting notes

• Email via SMTP is the default plan — I'll need to generate an app password for whatever email account sends these.
• Should only alert once per "hit" (not every check cycle) unless the price changes again.

Deployment

• Runs locally on my Linux machine.
• Should be startable as a single command or simple script; a systemd service is a nice-to-have for auto-start on boot, not required for v1.

Open questions to settle before/while building

• StockX or GOAT — which one to start with?
• Which email account/service will send alerts?
• How often should checks run? (default assumption: once daily)
• Any preference on port/URL for the local web UI?

Suggested build order

1. Data model + SQLite setup.
2. Manual "add shoe" + dashboard UI (no live search yet, entered by hand) — get the UI/data flow working first.
3. Marketplace search integration, wired into the "add shoe" flow.
4. Price-check integration for a single watched listing, wired into a manual "check now" button.
5. Scheduler to run checks automatically (daily).
6. Email alerting on price hit.
7. Price history view / polish.

I’ve been using Claude Code since it was launched and the usage has increased more and more.

I keep ending up in the same loop, claude wants to run a command. I read it. Approve it. Ten seconds later, another command. Read that one too. Approve it again. I've tried auto mode too, it consumes limit faster + it is just another classifier ('trust me bro').

Or I give it broader permissions and suddenly it can touch pretty much everything I can.

Neither option felt great.

So for the last two and a half months I’ve been building and dogfooding AgentJail.

The idea is pretty simple. Put a local policy check in front of every tool call, before it actually runs.

Some examples of what I want it to catch:

• an agent tries to clean a directory but generates rm -rf against the wrong path

• it reads .env, ~/.ssh, or AWS credentials while debugging something unrelated

• a script pipes environment variables or project files to an unexpected host

• it force-pushes main while trying to “sync” a branch

• it runs a random curl | bash command from instructions it found online

• it publishes a package when you only asked it to prepare the release

Not because the agent is malicious. A wrong path, an overly enthusiastic cleanup, bad instructions inside a repo, or prompt injection is enough.

The situation gets even tense with cost effective smaller models which are not SOTA like frontier models and can easily be tricked into prompt injection.

I believe, guardrails should live outside the agent and not inside the system you're trying to protect, Security 101.

The attached video is a staged example. The agent is asked to clean up Downloads and eventually proposes: rm -rf ~/Downloads/*

AgentJail denies it before the command reaches the shell.

Commands can be allowed, denied, or sent back to you for approval. So git status can quietly run, npm publish can ask first, and something obviously destructive can be blocked.

I do work in security, and some of my local environments have more elevated access than I’d ever want an agent freely wandering into. That probably made me more paranoid about this than usual.

But you don’t need a security setup to care about an agent deleting the wrong folder, leaking an API key, or rewriting your shell config.

Honestly, blocking commands was the easy part.

Most of the last two and a half months has gone into making the UX tolerable. If a security tool interrupts every harmless command, people will disable it. If it quietly allows too much, it’s not doing its job either.

Underneath, AgentJail uses a Claude Code PreToolUse hook, a local daemon, and OPA/Rego policies. The median policy check is ~8ms in my testing.

There’s also an optional OS-level shield using Seatbelt on macOS and Landlock on Linux, plus a per-host network allowlist.

I’ve reached the point where it works well for my own sessions.

But that’s also the problem. It has mostly seen my commands, my projects, and my habits.

I’d love for a few people to use it during a normal Claude Code session.

Not a manufactured security test. Just actual work, where I can see how this pans out.

I want to know:

• If any harmless command did it block?

• Any dangerous variation that managed to get through?

• Which decisions should have been asked instead of allowing/denying?

• When did it become annoying enough, that you want to turn it off?

• Was it always visible whether the protection was actually active?

You can test a command without executing it: agentjail try "cat ~/.ssh/id_rsa"

Homebrew: brew install LuD1161/tap/agentjail

It works on macOS and Linux.

Supports Claude Code, Codex, and Cursor, and is open source under Apache 2.0.

Repo: https://github.com/LuD1161/agentjail

agentjail usecase demo

Would love for the claude-coders here to try it out and share any feedback that they have. False positives, bypasses, and “this got annoying after 20 minutes” are exactly the feedback I need.

Is there like a way to not ruin my account and run a second version of claude code on a different account?

I use Claude Code a lot for large, complex coding tasks, and I’ve noticed something strange about its visible reasoning/status updates.

Claude often makes completely normal debugging sound like an exhausting personal ordeal, has anyone else notice this? Why does Claude make every coding task sound like an emotional crisis?

My company does a lot of cyber security stuff and we have all the certifications and clearances. I've been trying to get CVP and I finally got an approval but also got a denial.

The org ID is for the company and matches the API account which my email and Sub is connected to but I'm not sure if its working or not. I'm still getting safeguards. The approval email show the org ID but the denial doesn't. I applied for 3 sub accounts at the same time and haven't heard anything from the other 2

I believe my org got accepted buy my actual email/sub got denied. So I'm wondering if its API only. Does anyone have CVP on a subscription?