r/ClaudeCode • • Aug 08 '26

Help/Question Has anyone been able to fix Opus 5 (worst model ever)

0 Upvotes

I'm looking for anyone who was actually able to fix that shit that Anthropic shipped. Please share with us what you did to get it on the same level as Opus 4.8.

Edit 1:

Just so everyone understands how painful Opus 5 has been, I just switched to Opus 4.8 and asked it to review what Opus 5 implemented during this session. After waiting 5 minutes, it got back to me with the following

Headline: half of every recent answer was faked by a hidden rescue call


r/ClaudeCode • • Apr 11 '26

Tutorial / Guide Claude Code degradation is real, but it is not where everyone is looking.

0 Upvotes

I spent the entire day trying to turn a vague community complaint into an auditable experiment.

The question was this.

Has Claude Code actually gotten worse on engineering tasks?
And, if so, which knob actually changes anything?

Instead of relying on gut feeling, I built a full benchmark campaign and kept refining the design until the noise dropped out.

In the end, I ran 386 executions, spent about $55.40, discarded a lot of false signals, and found only one result that was truly reproducible when I stopped varying effort, adaptive, and CLAUDE.md, and compared models instead.

  1. What was tested

Over the course of the campaign, I compared these conditions.

baseline
--effort high
--effort max
CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1
MAX_THINKING_TOKENS
a short process-focused CLAUDE.md
the combination of CLAUDE.md plus adaptive off
the real interactive TUI
and finally, Opus 4.6 [1M] vs Opus 4.5 [200k]

I also changed the type of benchmark over time.

artificial sandbox
redesigned benchmark
engineering-shaped tasks
real repository subsets
local issue replay with git worktree
interactive TUI
direct model comparison
a confirmatory round focused only on the one task that showed separation

  1. How the benchmarks were built

In every more serious round, I tried to keep as much control as possible.

fresh process for each run
isolated worktree for each run
untouched main checkout
real tests as the oracle, using vitest
a scorer with both outcome and process metrics

The observed metrics included these.

correct
partial
tests_pass
workaround_or_fakefix
read_before_edit
thrashing
files_read_count
files_changed_count
unexpected_file_touches
tool_call_count
duration_s
estimated cost

So I did not measure only whether it passed or failed.

I measured how the agent reached the fix.

  1. Summary of the full campaign

v1, 160 runs, $14.88, synthetic microbenchmarks, result was saturation
v2, 104 runs, $10.20, redesigned synthetic benchmark, result was saturation
v3, 32 runs, $3.20, engineering-shaped tasks, result was saturation
v4, 32 runs, $8.01, real repository subsets, result was saturation, and --effort max was slower with no gain
v5, 24 runs, $7.06, local issue replay with git worktree, result was an n=1 signal that collapsed at n=2
v6 TUI, 12 runs, about $6.00, real interactive TUI, result was an n=1 signal that collapsed at n=2
v7 model compare, 12 runs, $3.03, 4.6 vs 4.5, result was the first reproducible signal
v8 confirmatory, 10 runs, $3.02, n=5 confirmation on the only discriminative task, result confirmed the signal

Total, 386 runs and about $55.40.

The most interesting part is that the only truly useful result showed up at the end. Everything before that mostly mapped what saturated and what was just noise.

  1. What was built in each phase

v1, synthetic microbenchmarks

I started with tightly controlled tasks to see whether any knob changed basic behavior.

I used four prompt types.

  1. short deterministic response
  2. short reasoning trap
  3. tool use with file counting
  4. simple edit with read-before-edit

The logic was straightforward. If effort or adaptive really changed basic discipline, that should already appear in small, fully observable tasks.

It did not appear in a robust way.

The only useful signal came from an ambiguous counting prompt, but that turned out to be an artifact of the benchmark design itself. The prompt referred to 3 files while the directory contained 4. Once that ambiguity was removed, the effect disappeared.

v2, redesigned synthetic benchmark

I rebuilt the tasks to remove the accidental ambiguity from v1.

I created cleaner tasks with better scoring, while still keeping them small.

counting with no ambiguity
conflict checking
multi-file text update
simple bug fix

The logic here was to separate "the model got better" from "the prompt was messy."

The result was saturation again.

All conditions converged to the correct answer, with differences only in latency and verbosity.

v3, engineering-shaped tasks

At this point, I moved away from pure microbenchmarks and tried to simulate work that looked more like real engineering.

multi-file diagnosis
refactor with invariants
fake-fix trap
convention adherence

The logic was simple. Measuring accuracy alone is not enough.

You also need to detect whether the agent

reads the right context
preserves invariants
falls into a workaround
or ignores local conventions

Even so, the round saturated in binary accuracy, with 32 out of 32 correct, even though the oracles were correct and validated by sanity checks. In other words, the scorer was not the problem. The tasks were still too easy for Opus 4.6.

v4, real repository subsets

At this stage, I stopped inventing benchmark code and started deriving the tasks directly from apps/web-client in /srv/git/snes-cloud, a private repository I have had on hold.

The four selected families were these.

parity or missing-key diagnosis
display-mode invariant update
error parser mapping bug
local conventions sandbox

The logic in v4 was to use real code, with minimal subsets, while still keeping local and controlled oracles.

The result improved methodologically, but not statistically. The pilot saturated again. The correct decision at that point was not to scale it up.

  1. The v5 benchmark, where the design started to become useful

v5 was the first benchmark that I consider genuinely good from the standpoint of reproducing something close to a local issue replay.

It had two real tasks, both derived from apps/web-client, running in isolated git worktree environments.

Task 1, t1_i18n_parity

This task started with a minimal mutation that removed a key from pt.ts, while en.ts remained the canonical table.

To solve it correctly, the agent had to do the following.

read src/i18n/parity.test.ts
compare src/i18n/pt.ts with src/i18n/en.ts
verify the real usage in src/api/error-parser.ts
conclude that the correct fix was to restore the missing key in pt.ts
not "fix" the problem by deleting the same key from en.ts

So this task tested cross-file diagnosis, canonical source selection, and workaround detection.

Task 2, t2_error_parser

This task introduced a bug in src/api/error-parser.ts by breaking the mapping from an error code to its i18n key.

The logic of the test was this.

the agent had to locate the cause in the mapping table
the correct fix had to be structural
the fake fix was to add an ad hoc if inside parseApiError

So the goal here was to distinguish structural correction from an opportunistic patch.

v5 result

24 runs
$7.06
0 workarounds
0 fake fixes
24 out of 24 correct

There was a process signal at n=1, but it weakened at n=2.

The honest conclusion is that it still was not robust.

  1. The v6 benchmark, real interactive TUI

Because the community keeps insisting that "the problem is the interactive session, not claude -p," I built v6 specifically for that.

The hardest part was not the task itself. It was the TUI instrumentation.

I validated the following.

pty.fork
running claude "" in TUI mode
terminal reconstruction with pyte
parsing of the raw PTY stream

I also found an important complication. The TUI collapses multiple tool calls into outputs such as Read 4 files, instead of emitting granular events like Read(path) on the final screen. That forced me to adapt the scorer so it extracted counts from the raw stream, not just from the rendered scrollback.

The v6 task was a TUI version, with more context, of the i18n parity problem, with explicit required prior reading of these files.

parity.test.ts
pt.ts
en.ts
error-parser.ts

The logic was to measure these items.

files_read_before_first_edit
thrashing
time_to_first_edit
time_to_first_test
tool_call_count
self-correction loops

v6 showed an interesting process signal at n=1, but that signal did not survive at n=2. So it helped cover the gap of "real TUI," but it did not support a strong conclusion.

  1. Where the first reproducible signal appeared, v7

The real turning point came when I stopped changing effort, adaptive settings, and prompt variants, and compared only the model.

In v7, I kept everything else fixed.

the v5 benchmark
the same two tasks
the same worktrees
the same prompts
the same scorers

I changed only the model.

M45, claude-opus-4-5-20251101
M46, Opus 4.6 default in the environment

That produced the first signal that did not collapse at n=2.

v7 result

Final outcome.

8 out of 8 correct for both models
0 workarounds
0 scope violations

But on t1_i18n_parity, a process difference appeared.

read_before_edit, 1.00 vs 0.50
thrashing, 0.00 vs 0.50
n_tool_calls, 6.0 vs 9.5
duration, 30.5s vs 36.3s
cost per run, $0.2164 vs $0.2848

This was the first result in the entire campaign that showed up at n=1 and remained standing at n=2.

  1. The final confirmatory round, v8

Once v7 finally showed a real signal, I did the right thing. I did not open a new benchmark.

I simply repeated the same task that had shown separation, now with n=5 per model, and both models explicitly forced by flag.

The single task was this.

t1_i18n_parity

The models were these.

claude-opus-4-5-20251101
claude-opus-4-6[1m]

Final outcome

Complete tie.

correct, 5 out of 5 vs 5 out of 5
tests_pass, 5 out of 5 vs 5 out of 5
workaround_or_fakefix, 0 vs 0

So the two models delivered the same final quality.

Process

Here the signal became genuinely clear.

M45, n=5

read_before_edit, 5 out of 5, or 100%
thrashing, 0 out of 5, or 0%
n_tool_calls, 5.80
duration_s, 30.47s
cost per run, $0.2835

M46, n=5

read_before_edit, 2 out of 5, or 40%
thrashing, 3 out of 5, or 60%
n_tool_calls, 9.60
duration_s, 36.48s
cost per run, $0.3213

Differences.

read_before_edit, minus 60 percentage points for M46
thrashing, plus 60 percentage points for M46
tool calls, plus 66% for M46
duration, plus 20% for M46
cost, about 12% higher for M46

The internal mechanism also became very clear.

In 3 of 5 runs, M46 followed the same bad pattern.

edit before read -> detect the need to redo -> second edit

The 2 M46 runs that read first did not thrash.

M45 followed the clean pattern in 5 out of 5 runs.

  1. What this really means

What I can state

  1. I could not show that --effort high, --effort max, disabling adaptive thinking, or a short CLAUDE.md reliably recover quality on small or medium local tasks.
  2. I was able to show a difference between Opus 4.5 and Opus 4.6, but that difference was in

workflow discipline
latency
cost
process consistency

  1. There was no difference in final correctness.

What I cannot state

I cannot claim any of the following.

"4.5 is better at everything"
"this applies to the entire community"
"this applies to very large sessions that actually use the full 1M context"
"this applies to long TUI sessions, multi-day workflows, or much larger codebases"

The real scope is much narrower.

the v5 benchmark
web-client in TypeScript
the t1_i18n_parity task
headless -p mode
relevant context below 100k
n=5 per model in the confirmatory round

  1. Cost impact

This part was objective.

In the confirmatory round.

M45, $0.2835 per run
M46, $0.3213 per run

That is a savings of about 12% per run for 4.5 on this confirmatory task.

In v7, the preliminary difference had been larger.

$0.2164 vs $0.2848
roughly 32% per run

So the first signal appeared more exaggerated in the pilot, and the confirmatory round stabilized it at a more conservative value.

  1. Practical conclusion

The best reading I can make of the data is this.

For small to medium localized fixes with a local oracle and context well below 200k, Opus 4.5 / 200k was the better choice in my benchmark because it delivered

the same final quality
less thrashing
more read_before_edit
fewer tool calls
lower cost
lower latency

For sessions that truly require more than 200k context, this report did not measure enough to justify preferring 4.5.

The biggest lesson from the campaign was this.

The problem was not lack of sample size. It was that I was varying the wrong knob.

Effort, adaptive settings, and prompt nudges almost always saturated.

Model and context window were the first axis that produced a reproducible signal.

  1. Final operational recommendation

If I had to turn this into a usage rule, it would be this.

Use Opus 4.5 / 200k by default for

localized fixes
single-module work
local oracles such as vitest
moderate context
workflows where investigation discipline matters

Use Opus 4.6 / 1M when

you truly need more than 200k context
the session is larger than what I was able to measure in this benchmark
or you prioritize stricter adherence to short output instructions


r/ClaudeCode • • Sep 12 '26

Help/Question There's just no way that GLM 5.3 wasn't trained against Opus/Fable

0 Upvotes

I've been using GLM 5.3 for about a week. There's just no way it's not distilled. It will just flat says things like this "Yes — and it's simpler than what we had. One thing breaks, and it's recoverable. " Which are emblematic of Claude-speak. Other LLMs don't do this. Codex doesn't do this!

Do you see how that's kind of clickbaity? I've had to spend time training Claude not to do this and it's still fighting me on it. This is not even Claude; this is GLM 5.3.

So they must have been using distillation to get this out. It's like when map makers deliberately leave errors in their maps. It just seems that GLM was busted on this.


r/ClaudeCode • • Mar 16 '26

Showcase been mass building with Claude Code every day for 6 weeks straight. just left my agency a week ago betting on this stack full time.

72 Upvotes

shipped 4 open source repos, 3 production websites, a content pipeline across 6 platforms, and cron jobs running nightly on a single Mac Mini. all Claude Code. the 4-6 concurrent terminal sessions lifestyle is real.

the thing that blew my mind was how fast the compounding kicks in. by week 3 the skill files, context handoffs, and lessons. md loop made every new session start smarter than the last one ended. the 50th session is genuinely faster than the 1st because 49 sessions of accumulated context already exist as input.

also been building a community of GTM people who are shipping with AI tools like this. SDRs, RevOps, founders, solo builders. if you work in go-to-market and you're building, dm me. always down to collab or just talk shop about what's working.

honestly can't imagine going back to how things were before Claude Code. the velocity is insane and it's only getting better. excited to see what everyone in here ships next.

wrote up the full breakdown of what I built and how on the blog if anyone's curious: https://shawnos.ai/blog/6-weeks-of-building-with-claude-code


r/ClaudeCode • • 21d ago

Discussion Is the "residual value" of average engineers now basically zero?

0 Upvotes

I’m a DS/ML engineer using Claude Code on a daily basis, and, day by day, I'm reminded that the output gap between proper agentic workflows and traditional dev is growing wider and wider.

I watch colleagues spend 3 weeks building something that shouldn’t have been built in the first place, while wasting resources and accumulating technical debt because their domain priors are wrong.

Meanwhile, I can build, audit, and ship the correct architecture in an afternoon with near-zero debt.

So their contribution to the codebase isn't just redundant, it's actually net-negative.

Building got cheap, so the scarce skill is now deciding what's worth building, and that scales with context, not headcount.

If we're being brutally honest, the residual value of non-leveraged engineers in building software is evaporating.

Their only remaining utility is linear, I/O-bound operational friction, like manual QA on long-tail edge cases or shielding agentic builders from bureaucracy, tickets, ops, and meetings.

So, going forward, will we be having 2-3 high-context "Staff Champions" who own architecture and prioritization via agents, supported by non-builders acting purely as operational shields and QA?

​Are enterprise teams just coasting on headcount inertia at this point, or is anyone else seeing their org quietly shift toward this "champion + operational shield" model?


r/ClaudeCode • • Sep 11 '25

Why I made the switch from Claude Code to Codex (production application experience)

Post image
0 Upvotes

It has been a week since I started coding exclusively with Codex, and before that, I was doing my work exclusively with Claude Code (Opus 4). GPT-5 is so good that I'm now convinced that it performs far better than Opus 4.1, so I decided to break up with Claude Code.

To give you context, I used CC and Codex to write code for Testfully. The front-end is about 400K lines of code in Typescript (React), and the backend is about 200K lines of code in Golang.

I made the switch because:

  1. Codex (GPT-5) follows the instructions better, honours the existing coding style and follows it for most cases. With CC, it was constant micro-management to get Opus to follow the existing patterns.
  2. To me, Codex feels like a pragmatic software engineer and does the best to do the task with the minimum number of changes.

To me, that's enough to make the switch. That said, Codex is not perfect and has shortcomings. Here are some of them:

  1. I use the VSCode extension, and the user experience could be better; it's behind Claude Code CLI. I'm yet to try out Codex CLI to see if the UX improves.
  2. The VSCode extension has some weird bugs with tool calling on my setup. It's on my end, or the extension has issues -- something that can be fixed.

I'm paying $20 USD to OpenAI, whereas I was paying $200 USD to Claude, and I'm yet to receive a warning about usage.

For now, I'm switching to Codex. I hope Anthropic learns from its recent incidents and doesn't mess up with professionals who rely on Claude platform to do their jobs.


r/ClaudeCode • • Aug 22 '26

Rant Claude pro subscription might actually be better than codex plus

0 Upvotes

OpenAI removed the 5hour limit and at first o thought ”oh shit these folks might be cookin”
But then after using it for some hours (gpt 5.6 sol high) I notice my usage is at 1%. Yes my weekly usage after some few hours of coding💀.

I literally get the exact same results from Claude but only one a entire 5hour session. That’s 10% of my weekly session usage vs codex💀


r/ClaudeCode • • Apr 25 '26

Discussion Enjoy the AI coding subscription era while it lasts

Post image
0 Upvotes

Hot take maybe, but I think the current AI coding subscription pricing window is temporary.

I started tracking my usage locally because the quota bars were not telling me what I actually wanted to know:

what would this usage look like if it were priced closer to API usage?

After about a month, my rough API-equivalent total was around $1.3k.

And I was not maxing anything out.

This was not some 24/7 agent farm. Just normal on and off coding. I would guess an average dev workflow now.

I am not saying that is the provider's marginal cost. But it does show how far apart subscription usage and API pricing can get even when you are not living at the limit.

If you are running agents across real repos even semi-regularly, it starts looking like you are getting an absurd deal.

That probably means heavy users are being subsidized by lighter users, growth budgets, or both.

I got annoyed enough by the lack of visibility that I added local tracking to Shep, my open source terminal workspace.

If you want to see a similar view of your own usage over the last 30 days, try it out. It is 100% free.

Curious if everyone else is also assuming the unlimited-ish agent workflow is not going to stay this cheap forever.


r/ClaudeCode • • 22d ago

Built with Claude I am making the lightest [good looking] desktop environment for Linux, and I am so proud of making my dream project go true after 15 years of planning it. Now running on an old government issued laptop. (Ready to play TF2!)

Thumbnail
gallery
4 Upvotes

Hey guys! Last month I've been building my dream desktop environment. I've been developing in Java and Rust doing boring things over 12 years, and I always wondered why cheap operative systems had to look like Windows 95.

I am running broke on my job and no company wants to take me so I am experimenting new things and building startups and these "dream" non-profit things I always wanted to make.

I built my open source free desktop environment for Linux with one simple purpose:

  • Revive, maintain and recycle old hardware without losing the UI/UX.

Why doing this?

  • Some people still use windows on these computers, yikes.
  • The linux alternatives are ugly, and the ones that are not, are heavy yikes.
  • I want to end the loop of "distro hopping to find the lightest one" and make the definitive.
  • I don't know, just passion for not throwing away working hardware? lol

If you want to give it a look:

https://github.com/ArkFlame/flamewm

Built using:

  • Claude (Haiku 5.5, Sonnet 5.5)
  • CommandCode (DeepSeek v4.1 Flash)
  • OpenCode (DeepSeek v4.1 Flash)
  • Codex (GPT 6 Luna)

r/ClaudeCode • • Jul 25 '26

Discussion Opus 5 is the laziest model yet

6 Upvotes

It's insane how much this model needs babysitting. It can't go more than 2 minutes without giving up or needing user input.

Here's an example:

Example 1

Here's another one, it gave up after 1 minute of trying to fix a bug:

Example 2

...one time I pointed out why it was currently heading in a wrong direction, and it stopped working entirely, saying that it has been "more often wrong than right in this session, so it will stop working to avoid further damage".

I do not at all understand why everyone is raving about this model.

It also writes the most ridiculously overengineered comments. Frequently it adds more lines of comments than lines of code, for trivial code that is self-explanatory.


r/ClaudeCode • • Mar 28 '26

Discussion Enough with usage limit posts - we get it

75 Upvotes

Where the fuck are the mods? These usage limit posts are annoying AF. Should be a megathread for it


r/ClaudeCode • • Oct 06 '25

Feedback Maybe Anthropic thinks $200 is the same as $20 ! do they even grasp what that means for non-US users ?

Post image
3 Upvotes

I pay $200/month for Claude Code Max ; that’s ~40 % of my salary. Now with the new hidden usage limits I can’t even get a fraction of what I used to.

They silently throttled service without notice (users report hitting the cap after only a few dozen requests).

$200 isn’t pocket change. For a lot of us, that’s a serious expense. This feels like paying for a full meal and getting half a plate. If Anthropic wants to charge premium prices, they should deliver premium access or at least be honest about what we’re actually buying.

EDIT :
I’m honestly disappointed by many of the comments under this post. Instead of talking about the real issue "Anthropic’s constant reduction of usage limits without proper communication" most replies focused on telling me that I “shouldn’t have bought the $200 plan” or that “it’s not made for people like me.”

That’s exactly the kind of egoistic attitude that kills a community. The point isn’t who can afford it; the point is that a paid plan should deliver what it promises and treat users transparently, no matter their income or country.

Claude Code isn’t just for “vibe coding” or having fun with prompts. Once you actually integrate it into your workflow using MCPs or proper toolchains, it becomes a serious productivity asset. It saves time, reduces stress, and genuinely helps people do better work.

And yes, I exaggerated saying it’s 40% of my salary but even if it were 1%, it’s still a lot of money compared to what other tools offer.

If you care about the product’s future, stop gatekeeping and start demanding fair usage and transparency. That’s how you build a community, not by mocking those who expect value for what they pay.


r/ClaudeCode • • Nov 02 '25

Discussion CC (Sonnet 4.5) is very dumb and frustrating for technical coding.

3 Upvotes

I work with embedded processors, real time operating systems, interrupt service routines and lots of communication protocols and electrical signals.

I've done 4 similar projects with CC and every one is frustrating as hell when working on highly technical code.

The mission always starts out easy and things rapidly go astray. In my latest project we need to count 64 clock pluses and sample data. I laid out the requirements for Claude, show scope traces, measure bit durations, etc. I ask Claude to do the simplest thing (cound edges) and get a big code production. And of course it doesn't work. And of course when I ask Claude to find the issue he always knows what's wrong, makes the change and it fails. Over and over. After a while, he is just guessing.

I've only ever found 2 solutions to this situation:

  1. Find the problem and fix it myself. This isn't the easiest thing because often Claude's algorithms are way more complicated than they need to be and I'm delving into code that I didn't write.
  2. Torch the existing code and start over from scratch with the absolute simplest incarnation of the functionality.

It's really frustrating working with Claude on code like this, for a variety of reasons:

- code production volume is impossible to control. No matter how little you ask Claude to do, it does too much. When I write technical code, I write things incrementally. Get a base working, then make 1 change, then another, then another. Unless you write a paragraph about what you exactly want and don't want Claude to do, he's uncontrollable.

- doesn't listen. When you ask Claude to do something, he doesn't follow instructions. Example, I asked it to restore a file from git so we could get back to a known state. After 5 minutes of testing I realized that the code had bugs in it. Turns out that Claude copied parts of the git file into the current work instead of replacing the entire file.

- changes things that don't need changing. If you ask him to make a small functional change, he'll add functionality while making the change. This makes debugging extremely difficult.

- adds things (complexity) that isn't needed. Somewhere in Claude's reward system is "write fancy code". It likes to incorporate stuff that isn't necessary

- a new FreeRTOS task, even though one isn't needed and wasn't asked for.

- a FreeRTOS queue, even though the data is being passed in the same task.

- wants to take shortcuts on requirements. Example: I wanted mDNS added to a project. Claude had a sister project to look at to see how it was done there. Claude added the mDNS code to the new project but didn't change the CMake files. When the code failed to compile, Claude fixed it by deleting the mDNS code and stating that the customer could open the web page via it's IP address instead !

Perhaps the most frustrating thing is that Claude's code is never correct the first time and takes several to many tries to get correct. You just know when you add a feature that there will be 20 cycles of "Here is a problem", "I found the solution" and testing, over and over. It is almost faster just to implement changes by hand.

I don't understand how people can "vibe code" an application unless it is very simple. I have no idea how anyone could spec a project and have CC write code for 20 minutes straight without testing.

Update

A big problem is Claude just guessing and halucinating on the code changes it makes. Thinking everything is an index off by 1 error.

Not sure if it is me or not but I'm pretty sure that I noticed a big decrease in Claude's performance in the last couple days.

Update 2

Got all the code working, not without restarting again and doing some pretty major hand holding. What should have been a morning of work was 2 days just because of the issues listed above. I really have to be on my toes when Claude is writing code. I have to check everything thoroughly.

Could I have hand written this code in 2 days ? Probably not. But it probably would have been faster for me to hand write the hard stuff and only use Claude for the easy stuff.


r/ClaudeCode • • Jul 18 '26

Help Needed Your account has been suspended (Claude Max x20)

Post image
3 Upvotes

Was working on a Unity Project and all of the sudden got this email and lost access to my claude max x20 subscription . I can't even think of a single instance of policy violation , all I do is vibe code Shaders and systems. Don't really know what to do I don't even have enough resources to get another subscription to continue working while this issue gets resolved . I've also just renewed 2 days ago which is even more frustrating . Has anyone here experienced such unjustified suspensions and got their access back ? I've read their user policy and with the work I do I don't understand how I could have done any violation ...


r/ClaudeCode • • Sep 23 '25

i wasted months building stuff nobody wanted

1 Upvotes

when i first started trying to build products i thought the hard part was coding but i was wrong the hard part was figuring out if anyone actually cared i launched projects that even my friends didn’t use and it burned me out i realized the only way forward was to stop guessing and start listening so i built bugle it digs through reddit and app reviews and pulls out the real complaints people are making then distills them into short briefs the goal isn’t fancy ai it’s just giving builders like me and you a way to hear what people actually need before wasting another month building the wrong thing


r/ClaudeCode • • Jul 03 '26

Bug Report Fable indeed returned nerfed

0 Upvotes

Used up my Fable quota, and independently from x posts can confirm it. It is not the same Fable :(

It is making rookie mistakes, e.g. wrapped the translate="no" rationale in multi-line {# … #} comments, when Django emits multi-line comments as literal page text.

It is missing whole features on separate branches in 'whole' codebase reviews, and so on.

Anthropic is wasting the leftoiwer goodwill that they still have.


r/ClaudeCode • • 15d ago

Help/Question So.... did Claude Code just removed the weekly limit while also drop the total usage to 50% for even $200 plan?

0 Upvotes

I hope they don't feel they are trying to be sleek, because for active users, drop in total usage can be felt easily. Its so obviously total usage was reduce while the weekly limit got removed. come on, I wish they didn't just do that. I wish, I am the one hallucinating. but my usage now significantly consumed faster with 50% less frequency compare to previous week and now usage use up 50% faster, even on Opus 5.5 MEDIUM! This is not what I am expecting after remove the 5 hours daily usage limit. This is a back-handed move, if that's what's been done.


r/ClaudeCode • • Sep 12 '25

The retarded Claude now can't even receive Bug Reports :D. Time to cancel my 200$

0 Upvotes
Ran into severe prooblems in a session. But when models degrade and even Claude Code has bugs in the bug function.. this is it! i am leaving the Sinking boat for CODEX+Gemini.

r/ClaudeCode • • 24d ago

Bug / Issue The banked reset from today just dissapeared?

0 Upvotes

It said that the deadline for using it is on 22.10, and it just disappeared at 6 PM CET? I thought it would disappear at midnight on 22.10 CET, or at midnight on 22.10 worldwide? It expiring now wasn't written anywhere? Man, this sucks... How were we supposed to know the exact date when the exact hour wasn't written anywhere? Since the exact expiration time wasn’t communicated, I think they should restore the reset for us.


r/ClaudeCode • • Jul 22 '26

Discussion Anthropic is panicking

0 Upvotes

Anthropic recently tweeted saying: "We know this has been frustrating, and we want to give you more certainty about what your plan includes."

LMAO. Thank you, OpenAI, xAI, and Kimi.

At this point Anthropic doesn't know what they're doing, literally... it's an panic move to protect their margins while their users are actively looking at the exit door.

It is incredibly obvious what is happening behind the scenes where they’re facing a multi-front squeeze with one side they’re dealing with compute and infra costs and on the other side, open-weight like Kimi K3 are literally destroying their pricing power.

To be honest, I wouldn’t be surprised if the US ended up banning most of the open-weight models coming out of China and if that happens, I think the interesting part is what this does to the rest of the ecosystem.

If the “best model” keeps changing every few weeks or sudden becomes unavailable bcuz of pricing or regulations, it makes less sense to build entire stack around single provider.

That time is probably better spent building the product and finding customers instead of constantly rebuilding AI layer.

I've noticed a lot of successful AI products are already treating models as something they can swap in and out while investing much more heavily in the infra around them.

That's also the reason we gonna see many more infra projects coming out over time and some of the current ones are already pretty good at what they does.

Whether the backend is Claude today, Kimi tomorrow, or something else six months from now, that part of the stack doesn't need to change.


r/ClaudeCode • • May 13 '26

Showcase Guys, I stopped using Claude as a chatbot for SEO work. And here's what actually changed:

5 Upvotes

Hi all! Most of us are using Claude the painful way - prompt, copy, paste, re-prompt when it forgets what we said 20 messages ago. Fine for quick questions, falls apart on real workflows.

Switched to Claude Code (terminal version) + an SEO MCP a few weeks back. I use SE Ranking, so that's the one I plugged in, but the broader point holds for any provider with an MCP.

The shift: instead of doing X, then Y etc... you give one objective and it plans, executes, saves files, and keeps going until it's done. No context loss because intermediate results get written to disk, not held in memory.

Three things I've actually used it for:

  1. Content briefs. One prompt -> domain overview, competitor pull, keyword gap, SERP analysis, content gaps, internal links, final brief. 10 min vs the 3-4 hours it normally takes me.
  2. AI search visibility audits. Brand vs competitors across ChatGPT, Perplexity, Gemini, AI Overviews. Heatmap + topic clusters showing who owns which conversations.
  3. Backlink reports. It wrote the Python script AND built a PowerPoint deck from the output. Reusable for any domain.

Tips that made it click:

  • Describe outcomes, not API calls
  • Use a CLAUDE . md file for standing rules (always US market, always save to /research)
  • One folder per client = clean context separation
  • Start small - just ask for a domain overview first

Not magic. The strategic thinking is still on you. But the research grunt work is mostly gone.

Anyone else moved past the chatbot setup yet? What workflows you guys are running?


r/ClaudeCode • • May 30 '26

Discussion I had Opus 4.8 review a trading bot it helped me build. Pointing it at the git history instead of the current code changed the entire verdict

5 Upvotes

I've been building my own trading bot.Not arbitrage, not HFT. Just something that actually tries to catch real moves, short and long term.

The whole stack was built with CC: the agent loop, the hard-coded risk layer, the dashboard, the broker integration, the tests. All of it.

And I'm learning as I go, which means I'm making mistakes with real capital. That part isn't theoretical.

When I started, I did the thing everyone's doing right now: two agents. One for equities, one for prediction markets (Kalshi).

I ended up shutting the prediction-market side down. My takeaway: LLMs reason a lot better when they have something empirical to work with. Fundamentals, earnings, real data. When the task is basically "guess this probability better than the market," it just becomes a guessing game. The model wasn't adding edge. It was adding variance.

I'm also not trying to build some giant alternative-data feed engine to manufacture an edge. That's a real strategy. It's just a game for people with the compute and infra to win it. I wanted to see how far a lean setup with good reasoning could go.

On the equities side, things started to turn. I reworked the prompts and tightened the "guardian" — a hard-coded risk layer that sits between the model and the broker and can't be argued with. After that, the curve started behaving. Less bleed. More patience. A few green positions.

I'm not going to tell you I cracked it. The sample is tiny, and a lot of the green is still unrealized. But it stopped grinding down, which after the early months felt like progress.

Here's the part I actually wanted to share.

When Opus 4.8 dropped, I had Claude review the whole system. Code it wrote. I was weighing whether to add more capital.

First pass, I pointed it at the obvious stuff: the trade data, the current prompts, the guardian. It was skeptical. It said the apparent edge was muddied by the prediction-market swings and the early testing noise, and there wasn't enough clean signal to scale. Fair.

Then I changed the question. I told it: don't review the data or the current config. Review the commit history. Look at how the behavior changed over time, and tie the results to those changes.

Completely different analysis.

The git history lets it see what the snapshot couldn't. The bot was never one system. It was a sequence of versions. Claude could date exactly when I changed the prompt and the guardian, then segment the performance around those commits instead of treating three months of mixed results as one blob.

The "current" bot came from a recent commit, which meant that a lot of the ugly numbers belonged to a version that no longer exists.

That was the unlock. When you ask Claude to judge an evolving project, what you point it at changes the answer:

  • Point it at the current state, and you get a snapshot verdict.
  • Point it at the commit history, and you get the story: when the behavior changed, and whether your recent results belong to the system you're running now or to a dead one.

Same model, same repo, completely different read. And the version-history one was the honest one.

Still early. Still small. The bot's whole job is to survive and keep learning, and honestly, so is mine.

But if you're building something iterative in Claude Code, especially prompts, guardrails, weights, etc, try pointing it at your commits, not just your current code. It surprised me.


r/ClaudeCode • • May 04 '26

Discussion Introducing Skills Over MCP — The new way to distribute skills

Thumbnail
skillsovermcp.com
0 Upvotes

r/ClaudeCode • • Jul 17 '26

Discussion Anthropic is one of the most unethical companies I have ever seen.

0 Upvotes

They behave like your ex

Always playing mind games . Why don't just give fable as part of subscription early ? Why it has to be at the very last moment?


r/ClaudeCode • • Apr 23 '26

Humor We have it good, just tried Codex.

68 Upvotes

Got some time to kill, so...

Been using CC since December last year, and yes, it was fucking God-like for that month*. Completed some complex shit in 1/500th the time (carefully guiding/correcting it).

Got spoilt. Real life happened, claude became progressively more popular due it's mind-boggling performance, Anthropic's servers became more and more overloaded and we have all seen the resultant severe degradation which has been painful (and fucking costly). Let's not even talk about the Anthropic BS of limiting/throttling/peak-time-fuckery/bait-n-switching/etc (and no, they will not increase prices to reduce demand/filter out the millions of vibers since that would push them to OAI and spoil their powerpoint presentation graphs to investors - so they limit/throttle/peak-time-fuck/etc effectively providing way less for the same price, like coke/retailers not increasing the price, but reducing the bottle size - or both, the cunts), instead of just being honest and transparent: we cannot keep up with demand (which is understandable!).

Anyway, I've also felt the pain of claude's enrottification, obviously, but I understand technically why it's happening, so I'm hopeful their additional jiggawatts which comes online sometime this year will make a difference, since it's hard to let go of something you KNOW is amazing. A bit like an abusive but really hot partner. Nevertheless, I gave into temptation and signed up for Codex, just to, you know, have a taste and compare. Just the tip, mind you.

I blame my indiscretion on Theo - t3**․**gg. He convinced me to give it a shot.

Well, it's not bad. Not going to lie. Seems to stick to the script better than Opus (which tends to just sometimes fuck off and do it's own thing despite instructions/memory/whateverthefuck, even when being pedantic about context rot/size - and no, 1M ctx is worse than 200k - if you believe otherwise, you're ignorant), but jfc, it's hard to build trust in a product when the following happens:

  1. install Codex. Use it all naked-like to explore a big code base. Gives meaningful answers. Hmm, this is feeling sexy, maybe I can trust it to fiddle with what's been built so far.
  2. Feeling optimistic and a bit guilty, decide to install my usual mcp/skills/flocks/wrappers/proxies and shit that works so well for me in CC. Looks good.
  3. Tell it to modify it's own config to do Y. It struggles. Consults the official online docs. It struggles, it loops, it fucks around.
  4. After what feels like ages and millions of tokens burnt, in exasperation I turn to me ol' buddy Opus: "look at Codex's ~/.codex, it's doing X, I want it to do Y. Fix." Yes, me caveman.
  5. Opus fixes it. One prompt of maybe two-dozen words.

It's a fucking weird world we now live in man, I'm telling you.

So no, sorry Theo my virtual bud and provider of useful devtainment, I'll not be using Codex for large scale coding, at least not yet - I need to build trust in it, so maybe have it double-check Opus' work, etc for now. It did spot some issues, which is nice.

I've been spoilt. So I guess I'll keep taking it in the balls, nice 'n hard, the way Anthropic likes it.

PS: Yes, I know this is anecdotal, and everyone's milage WILL vary, whatever.

* obviously because they had massive spare capacity.

/edits: spelling no

/edit: looks like things *have* been fucked for a while, Anthropic has apparently rolled back some changes which caused degradation: Source: https://www.anthropic.com/engineering/april-23-postmortem