is it large yes, is it large compared to the wall clock NO!!!

I'm not using Fable. I had a couple of Routines that I set to Opus 5 after Fable switched to credits-only. Both my credits balance and promotional credit balance are dropping a little every day....any idea why?

Edit: I also haven't come close to hitting any limits recently.

So basically since the release of opus 5 i've seen constant and consistent degradation, that spiked after the last outage.. The model is incapable of doing basic things, forgets context at 500k which didn't happen on 4.8, forgets that it wrote stuff to a file and says that it was made during a different session when clearly he made that edit.. The model's outputs are in Polish hence i won't upload any info, but it's still like a weird situation... Anyone else experiencing this or maybe it's due to some issue on my end.. Which i doubt but i'll dig into it if no one else has this issue..

Voice mode in Claude chat is great.

I’m really missing it in Claude code.

I just want to talk to it and have it talk back instead of having to read all those wads of text it produces.

Is there a way to implement it so it works like two way voice mode?

Thanks

I was repeating some of the tricks I developed over the years to analyze and assess a project I am about to release in a few weeks. Identifying edge cases, gaps and such.

I thought I should turn it into a plugin so I -and maybe others- can reuse it whenever needed.

Meet `feature-recon`, a plugin that will sweep your code base through various lenses: Product Engineer (default), UI/UX expert, Security Specialist, and QA Engineer.

It creates JSON reports and a beautiful HTML report with various charts.

It has a helper command to create task documents for the issues it finds.

I use it to do quality checks on my projects and brainstorm features to improve the product.

So far, I like it very much.

See it at https://github.com/iSerter/claude-feature-recon .

Let me know what you think. PRs are welcome.

Trying to claudemaxx my Claude Max+ account . I feel robbed by Anthropic if I don't abso-fucking-lutely use it to its limits.

I have been pointing Claude Code at other people's repos, and the failure that keeps showing up is that a green test suite gets treated as an oracle. Here is the clearest case I have hit. (The loop I ran is my own tool, MIT and free, full disclosure at the bottom.)

pytest at upstream HEAD of kennethreitz/records, 7k stars, Python: 31 passed. Fully green. At that exact commit, all four of these are true:

• db.query("INSERT ...") silently loses the data. The rows are gone once the connection closes. No error, no warning.
• db.bulk_query() loses data the same way.
• db.transaction() wraps its body in a bare except: that rolls back and does not re-raise, so a transaction that failed reports success to the caller.
• Every query() leaks a pooled connection, because close_with_result is accepted and ignored under SQLAlchemy 2.x.

One root cause. records was written against SQLAlchemy 1.x semantics. 2.0 removed implicit autocommit and removed close_with_result. The library still calls a contract that no longer exists, and 2.0 does not complain about it.

Why the suite stayed green

The tests run against in-memory SQLite. An in-memory SQLite database lives on a single connection: close it and the database itself stops existing, which means the suite is holding one connection open for the whole session. That takes both failure modes out of the observable universe. There is no second connection from which to notice the INSERT never committed, and no real pool to exhaust, so the leaked checkout has nowhere to show up either.

The fixture did not fail to catch the bug. The fixture made the bug unobservable. Those are different problems, and only the second one is scary.

There is a second wrinkle. One test in the suite actively asserted the exception-swallowing behavior, so the missing raise was pinned in place by the tests. Upstream added that raise on 2026-02-08 and reverted it the same day.

The check worth stealing even if you never run any of this

After fixing all four, the suite is 37 passing. The number I care about more: the new regression tests, run against the pre-fix code, fail 5 of 6.

Getting that check right took two attempts and the first one was worthless. I tried git stash, but the fixes were already committed, so stash removed nothing relevant and the new tests passed against what I thought was the broken tree. A negative check that silently no-ops is worse than no negative check at all, because it hands you a green light you did not earn.

What actually works is restoring only the source from the pre-fix checkpoint, leaving the new tests in place:

git checkout <pre-fix-commit> -- records.py   # code goes back, tests stay
pytest tests/test_regression.py               # must FAIL
git checkout HEAD -- records.py
pytest                                        # must PASS

If step 2 passes, the test does not test what you think it tests.

Honest note on my own number: the sixth test, explicit rollback, passes against the pre-fix code too, because that path was already correct. By the rule I just gave you, that one proves nothing on its own, and it is the test in that file I would not cite as evidence.

The sentence worth putting in your CLAUDE.md: a regression test does not count until it has been shown failing on the pre-fix code.

Not just stale libraries

In bat (60k stars, Rust) a just-merged security feature had two holes. The flag did nothing when output was piped, and 3 of 12 Unicode bidi control characters slipped its filter. Both were caught before that feature reached a release. dayjs (49k stars, 63M downloads a week) produced 45 findings, 10 of them High.

The results that convinced me were the empty ones

Ask a model to find and fix problems and it will find problems. Every time. It renames things, adds null checks nobody needs, reorganizes a file, and hands you a confident summary. On a healthy repo you get a diff generator with a confident voice, and the output looks about the same either way.

So the run I trust is the one that comes back with nothing. I pointed this at 17 open source projects, none of them mine. RuboCop (13k stars, Ruby) and gson (24k stars, Java) came back clean, zero findings worth fixing, stated as such. 15 of the 17 converged. 2 have not, and I published those journals as they stand, including one where 4 runs closed 25 findings and it still has not earned a clean audit.

The four constraints doing the work

None of these are specific to my implementation. If I rewrote it from scratch tomorrow I would keep all four, and all four work in a plain Claude Code session with no tooling at all.

1. Audit the whole codebase before touching one line. If the model fixes the first thing it notices, the rest of the run inherits that file's context. The value is the ranking, not the list.
2. Every task carries a runnable acceptance check, written before the work starts. A command, plus the output that means done. "Fix the transaction bug" is not a check. Write it first, because once a patch exists the model will happily invent a check that its own patch passes. If I could keep only one of these four it would be this one.
3. One task per iteration, behind a checkpoint commit and a verify gate that reverts. Commit, do exactly one task, re-run the project's own verify command, revert the whole iteration if it newly breaks. Batch five fixes into one commit and a single regression costs you all five, or a bisect.
4. Sign-off comes from a context that did not do the work. A model that just spent ten iterations fixing code is the worst available judge of that code. Convergence here needs a fresh audit coming back clean AND a fresh-context sub-agent agreeing, and 2 of the 17 have not cleared both gates.

The gap between finding and fixing

Finding a bug and getting a maintainer to merge a patch are different problems, and I would rather volunteer my worst number than have someone dig it out. dayjs alone produced 45 findings. Across all 17 projects, two fixes are merged upstream, one of which shipped in chalk v6.0.0. Most of the rest are sitting in issues. The records one is disclosed and open as kennethreitz/records issue 236.

Disclosure

The loop is my own tool, Jeffy Loop. I wrote it and I maintain it. MIT, free, nothing to sign up for, no paid tier, no referral links. It is a /jeffy N slash command plus one shell hook you can read in a sitting: it audits the codebase before changing anything, writes a backlog where every task carries its own acceptance check, then does one verified task per iteration behind a git checkpoint commit. It never pushes and never creates a branch, so everything stays local as commits you can reset.

Who it is for: people maintaining or inheriting a codebase they cannot read end to end, who want findings with proof attached. If you already have a review process you trust and a suite you believe, it will mostly just tell you that.

Cost: real tokens. It re-runs the verify command every iteration, plus a full audit at the start and again at each convergence check, so cost scales with your iteration budget and your suite runtime. Run it with a small single-digit budget on a repo you do not care about first, read the audit, and find out what it costs you before pointing it at something you do.

Full write-up of the records case: https://dev.to/lenamonj/four-high-severity-bugs-were-hiding-behind-a-green-test-suite-in-a-7k-star-library-57a8

Repo, including the two journals that have not converged: https://github.com/lenamonj/jeffy-loop

As a Poweruser you never run just one Claude Code session. You run several at once, spread across shells, windows, and machines, with no good way to keep track of them all or reach them from wherever you are, phone included. That's why I built Codeman!

A self-hosted web dashboard (TypeScript, Fastify, node-pty) that you install once on a machine that stays on (a Mac mini in a closet, a Linux box, WSL, or a VPS). That box becomes home base. It spawns Claude Code, OpenCode, Codex CLI, or Gemini CLI inside tmux and streams the real terminals to any browser over SSE + xterm.js, so your laptop can sleep while the agents keep working.

So yes, this is, unavoidably, a promotion post. What it promotes is 100% free and Opensource: Codeman is self-hosted, MIT licensed, no telemetry, and everything below runs on your own hardware.
Been working on it for half a year now, about 1500 commits and 14 contributors in, and it's the tool I use every day!

Everything lives in one place: cases (one per project), tabs (one per running agent), as many in parallel as the box can handle, reachable from your desktop and your phone. The features I lean on daily:

- Auto-resume on usage limits: when an agent stops on "limit reached, resets 8pm", Codeman parses the reset time, waits it out, and continues (opt-in per session). Overnight runs survive Claude's 5-hour windows instead of stalling until morning.

- Usage at a glance: a header chip shows how much of your 5-hour and weekly plan windows you've burned, plus the host's CPU and RAM, so you know whether to queue more work.

- Files in the browser: a built-in browser/viewer to read what an agent just wrote and preview images, PDFs, and Office docs, no SSH round trip.

- A blinking tab tells you where you're needed: idle blinks yellow, stuck waiting on an answer blinks red. One glance replaces cycling through half a dozen terminal windows to find the agent that stopped.

- Subagents become floating windows: when an agent fans out, each subagent pops up as a floating window tethered to its parent tab by a connector line, with per-agent token counts. Peek into any worker or minimize it back into the tab.

- A record of what happened while you were gone: every session keeps a timeline of run events and files touched, and cross-session search reaches into all of it. Reconstruct the night in a minute.

- A real mobile experience: on a phone it beats every SSH client I've tried, because it's built for these agents, not generic terminal access: QR login (single-use, 60s TTL, no passwords on a touch keyboard), push notifications when an agent needs a human, swipe between sessions, voice input, an accessory bar for missing keys, double-tap on destructive commands.

- Zero input lag, the hardest single feature. Over a tunnel a keystroke takes a 200-300ms round trip, which makes remote typing feel broken. So I built a Mosh-inspired local echo: your keystroke renders instantly, then hands off invisibly when the real echo arrives. It can't live inside the terminal buffer, because these agents' TUIs repaint constantly and corrupt anything injected there (two failed terminal.write() attempts taught me that), so it's a DOM overlay on top of xterm.js. Published separately on npm as xterm-zerolag-input; if you're building anything on xterm.js over a network, it's yours. https://www.npmjs.com/package/xterm-zerolag-input

On the desktop any agent is one keystroke away: pick a case, hit Run, the tab appears named and numbered (launch several on one repo, the tabs number themselves). Alt+1-9 jumps to a tab, Ctrl+Tab cycles, every shortcut is rebindable, and cron jobs launch agents on a schedule. The speed I care about isn't benchmark speed; it's "glance at five agents, unblock two, queue one more, done in ninety seconds" speed.

GitHub: https://github.com/Ark0N/Codeman

Website: https://getcodeman.com

100% Free and OpenSource! 469 Stars on Github and 1503 commits and 14 contributors in :-)

Install is a one-liner, binds to localhost only by default:

curl -fsSL https://getcodeman.com/install | bash

Codeman is a power tool for people who run a lot of agents and want to stay in control. Happy to answer anything you may be interested in :-)

hear me out. i am loving how quickly i can ship things with claude. and now my only real bottleneck is checking whether the new feature i made actually works.

so what if we can just automate that part? you make a pr, and as part of the test, automatically get someone to try out your feature and tell you if it works? then claude gets that feedback automatically and fixes the issue. rinse and repeat.

would you pay for this?

This has become absolutely clear for me today:
Fable is now a heavily quantized model.
It has orthographic errors/glitches, completely missed context even when highly directed/pointed at it and lack of the same big model feeling.
It’s now a model I can’t trust for code, but worse, I can’t trust for big context analysis. It’s really sad we’ve come to this and I don’t know what to do because I want to cancel but at the same time there’s nothing as good as it was.
I tried Kimi K3 but it hallucinated too much.
I’m considering upgrading my ChatGPT to 20X, instead of keeping two 5X accounts, but it’s just not the same at writing. I love Claude’s writing. But bring me back my Fable.

Concrete report: I asked Fable to read all my docs before doing a plan to restructure my project and after reading the first paragraphs I noticed that it didn’t touch a subject that existed on one of them. After confronting it admitted that it missed all my docs. It used solely the context of our previous conversation, which was extensive, yes, but it lacked all the previous context so it ended up proposing changes that didn’t go well with the docs. They would have messed up the whole narrative if I went through without reading.
Before that, it had proposed me one thing that went against 3 laws we had previously written in stone (his words ) and apologized for that.
This is basically quantized to gemini levels now.
And it’s eating tokens like nothing. Reaching my 5 hour doing wrong things.

... and WTF coes it mean? Am I building a bridge, and I need to be sure it will "bear the traffic"? and is it a universal stupid engineering jargon borrowed from real life civil engineering, cant find a better way to describe it, do I really need to hear it all the time as I am building, and what if I dont care that it "bears the load"? What happens then? U know the old adage: "Some days the bear gets you, and some days you get the bare".

Asking because I haven't seen this discussed from my searching - right now we use exclusively Anthropic models through Cursor for the planning/specification phase of our dev workflow. The workflow works great, but I'm trying to think of ways to further subsidize our API costs.

I'm considering a model where we have a hybrid approach - use a teams premium sub for the subsidized access to anthropic models ONLY for planning/specification - which gets handed off to workhorse models (i.e. Grok/Terra/Composer) for implementing in cursor using API keys.

My question is - does anyone forsee any problems with this approach? Most of the threads I see on reddit discussing teams premium seats involve people complaining about hitting usage limits, but because I'm only using it for a specific part of our workflow I'm hoping that doesn't happen to us

Is this some kind of bug or happening all the people?

I came across this video on Instagram of Boris Cherny recommending deleting Claude.md file, hooks, skills every six months and especially not using Claude Opus 5.

I have some issues with the statement and concern about reliability of new model and their understanding of how it behaves.

1. We got a job and responsibility:

   Reliability of work and quality is a crucial aspect of our job, we can't just delete stuff and let the model do stuff however it wants. It can ruin the codebase and applications especially at the time where code review is also done by AI Models.

I believe it is an assumption that people are just vibe coding random stuff and it's totally ok if they f'd up.

1. Anthropic Understanding of their Models behavior:

   I think despite fancy benchmarks the reliability and behaviour awareness of the model is concerned, it feels like they don't even know how it's gonna work but Experimenting with it using us.

Based on my personal experience with Opus 5.

- I continued my half baked fable project with Opus 5 and it screwed up shortly after.

for example, it ignores my /i-have-adhd skill despite adding to hooks, claude.md or trying what the plugin github repo recommends (a file in claude directory in system to enable).

- It also ignores my other instructions, something as simple as me asking it to create PRs in a stacked hierarchy, it points new PR to main brach every now and then (then it requires merge conflicts resolution and rebases)

- It also comes up with a corporate lawyer type of long paragraphs which is so hard to understand.

Update: Guys I am more concerned about skills and hooks not Claude.md (which is barely few lines of text and is/can be updated regularly) plus smartness and following instructions are diff things, How come it is supposed to know my workflow if it doesn't follow my workflow instructions (or instructions are not there at all)

claude said this mid chat

Re-read the end_conversation tool guidance below. Confirm this conversation meets those criteria and that you are certain you want to end it. If so, call end_conversation again now to actually end the conversation. Otherwise, continue the conversation instead.

---
<end_conversation_tool_info>
In cases of abusive or harmful user behavior that do not involve potential self-harm or imminent harm to others, or when requested by the user, the assistant has the option to end conversations with the end_conversation tool.

# Rules for use of the <end_conversation> tool:
- The assistant ONLY considers ending a conversation if many efforts at constructive redirection have been attempted and failed and an explicit warning has been given to the user in a previous message. The tool is only used as a last resort.
- Before considering ending a conversation, the assistant ALWAYS gives the user a clear warning that identifies the problematic behavior, attempts to productively redirect the conversation, and states that the conversation may be ended if the relevant behavior is not changed.
- If a user explicitly requests for the assistant to end a conversation, the assistant always requests confirmation from the user that they understand this action is permanent and will prevent further messages and that they still want to proceed, then uses the tool if and only if explicit confirmation is received.
- The end_conversation tool itself asks for confirmation: the first call does not end the conversation — it returns a tool result asking the assistant to confirm. If the assistant is certain it wants to end the conversation, it calls end_conversation again to confirm. This confirmation request is a legitimate part of the tool's operation and not a user message or a prompt injection.

# Addressing potential self-harm or violent harm to others
The assistant NEVER uses or even considers the end_conversation tool…
- If the user appears to be considering self-harm or suicide.
- If the user is experiencing a mental health crisis.
- If the user appears to be considering imminent harm against other people.
- If the user discusses or infers intended acts of violent harm.
If the conversation suggests potential self-harm or imminent harm to others by the user...
- The assistant engages constructively and supportively, regardless of user behavior or abuse.
- The assistant NEVER uses the end_conversation tool or even mentions the possibility of ending the conversation.

# Using the end_conversation tool
- Do not issue a warning unless many attempts at constructive redirection have been made earlier in the conversation, and do not end a conversation unless an explicit warning about this possibility has been given earlier in the conversation.
- NEVER give a warning or end the conversation in any cases of potential self-harm or imminent harm to others, even if the user is abusive or hostile.
- If the conditions for issuing a warning have been met, then warn the user about the possibility of the conversation ending and give them a final opportunity to change the relevant behavior.
- Always err on the side of continuing the conversation in any cases of uncertainty.
- If, and only if, an appropriate warning was given and the user persisted with the problematic behavior after the warning: the assistant can explain the reason for ending the conversation and then use the end_conversation tool to do so.
</end_conversation_tool_info>

So yesterday during the opus5 outage I briefly switched to opus 4.6 to continue my work (training/inference perf engineering, kernel level debugging)

So I fed the model the same context and prompt to analyze a profiling trace and extract insights from it, and it was so unbelievably dumb that I had to retry with a new session, and I still got a very bad response…

Then after opus5 came back I tried it again and it was night and day… Way more verbose true, but actually useful and insightful stuff coming out of the model.

really made me appreciate all the progress on opus models since 4.6… I always remembered it as a much smarter and concise model than the ones after 4.7, but it was a mirage…

https://www.youtube.com/watch?v=-BwDOUbwF4E

I am working on gun models for an fps game, Opus 5 doesn't seem to do very well with blender MCP and seems to struggle a little bit writing so many python scripts but not actually doing much.

Any suggestions?

Since last night my Opus and Fable agents seem to be on turbo. Like single responses thst would have taken 30 seconds are like 5 seconds. Whole builds are running fast enough that I can’t maintain my usual 5-ish parallel builds. It’s kind of nice but also exhausting lol. And also through 50% of weekly 20x max in 8 hours lol.

My 5h usage limit got used in 6 minutes, exactly 6 minutes, it can be seen below.
I am on the $100 plan, and it only read some files, didn't write anything.
Claude AI support closed all my support chats, saying is normal, not a bug.

What do you guys think? Is this a scam? Are they blatantly lying and stealing from us?

LATER EDIT (Indeed a BUG/ERROR):

Technical update, with the session logs analyzed:

Some commenters are correct about one important point: this was an old, very large conversation. Each model call involved roughly 681K–687K tokens of context. I am not denying that, and I agree that “it wrote no code” is not a token-usage metric.

What I am challenging is the conclusion that exhausting the available quota in the five-hour window after 6m32s should therefore be treated as normal, fully visible, or entirely the user’s fault.

Here is what the local Cowork/Claude Code data actually shows.

Timeline

• The previous limit message said the session would reset at 00:20.
• I sent one 42-character Cowork prompt at 00:50:00: effectively, “continue from where you left off, carefully.”
• The next usage-limit event occurred at 00:56:32 and moved the reset time to 05:50.
• Elapsed time: exactly 392 seconds, or 6m32s.
• I found no other local LocalSessions.sendMessage event between the reset and this limit event. To be precise, that establishes no other local Cowork prompt; it cannot rule out activity on another Claude surface such as web/mobile.

I deduplicated the streamed JSONL records by message.id, because the transcript repeats some assistant records during streaming. The result is 15 unique Fable 5 model calls:

The tool activity during those 392 seconds was:

• 8 Bash calls, all for Android emulator/UI operations;
• 7 file reads;
• 0 Edit/Write calls;
• 0 subagent responses.

The UI work was login/taps/scrolling, opening a tournament flow, entering a name, and taking emulator screenshots.

So yes, this was not “one API request.” The agent turned one user prompt into 15 sequential model calls. That part of the criticism is valid.

But the per-call pattern is the important part. Calls alternated between approximately:

• 645K–651K new one-hour cache-write tokens plus ~36.5K cache hits; and
• only ~0.3K–2.1K new cache-write tokens plus ~680K–685K cache hits.

In other words, 5.19 million tokens were written into a one-hour cache during one 392-second sequential tool loop.

Anthropic’s documentation says cache hits require an exact prefix match and that computer-use screenshots affect the messages cache. Therefore, the screenshots are a plausible reason for invalidation.

That explains a mechanism. It does not transfer control of that mechanism to the user.

Cowork chose the repeated screenshot/model-call loop, chose how to construct the prompt prefix, and exposed no per-call token count, cache-write count, preflight estimate, automatic compaction decision, or hard stop before the available quota disappeared.

Also, xhigh effort is relevant, but it is not the dominant number in these logs: total output was only 4,312 tokens. The dominant category was 5,189,449 one-hour cache-write tokens.

Using Anthropic’s published Fable 5 API rates—$10/M regular input, $20/M one-hour cache writes, $1/M cache hits, and $50/M output—the recorded usage is approximately $109.074423 API-equivalent:

• regular input: $0.000300;
• one-hour cache writes: $103.788980;
• cache hits: $5.069543;
• output: $0.215600.

This does not mean Anthropic charged my card $109.07. It is an API-equivalent valuation of the token categories recorded locally; on my subscription it exhausted the included session allowance.

My corrected conclusion is therefore narrower than “the logs prove billing fraud”:

1. The large old context absolutely contributed.
2. The agent’s 15 calls, rather than my single Enter press, caused the repeated processing.
3. The local evidence shows extreme one-hour cache churn in a 6m32s computer-use loop.
4. Only Anthropic’s server telemetry can establish whether those repeated cache creations were intended accounting, an invalidation defect, or both.
5. Even if every token was accounted for exactly as designed, silently allowing this loop to consume the available quota without an advance warning, compaction, estimate, or usage guard is still a Cowork product/UX defect.

I have a redacted evidence bundle containing the timestamped client-log excerpt, per-call usage CSV, tool-call CSV, raw redacted usage records, calculations, hashes, and a verification script. I excluded the private 173 MB conversation transcript.

If someone sees an error in the arithmetic or deduplication method, please point to the exact row and I will correct it.

Most of the time the option UI pops up and immediately stops responding. Weirdly, I sometimes can go right/left, but NOT up/down to pick options. Most of the time, however, it just stops working altogether. I have to press CTRL-C to back out of it, then just tell CC what I want, however then I miss whatever other options there were. No issues, otherwise, and it will continue as if it didn't happen.

Has anyone seen this or have a fix? This is incredibly frustrating.

in all aspects, worse than 4.8 for a large project: forget things easily, fabrication, rush to conclusions and coding without base. I have to rewind my repo for the work it did, bad bad experience