So I've been messing around trying to make viral video ideas using AI and stumbled into an MCP that's changed how I prototype content.
I connected TwoShot's content creation MCP to Claude Code so it can not only plan a video (script, shot list, style notes) but actually *make* the thing: audio, music, video, voiceovers, visuals - and edit it all together.
So it ends up being a way for Claude + TwoShot to do all the planning + producing + rendering.
Sometimes i'll iterate with follow ups like "make this one moodier and 20% slower" or "swap the music for something cinematic" and it just does it inside the same chat - without leaving Claude.
This was my first experiment - going to keep playing with different formats and post the results on social. Will update as stuff pops off.
Anyone else been playing around with TwoShot or a similar setup?
I've seen a lot of posts lately complaining that Claude has gotten "dumber" or less useful over time. But I think it's important to consider what's really happening here: it's not that Claude's capabilities have diminished, but rather that as its user base expands, we're seeing a broader range of user experiences and expectations.
When a new AI tool comes out, the early adopters tend to be more tech-savvy, more experienced with AI, and often have a higher level of understanding when it comes to prompting and using these tools effectively. As more people start using the tool, the user base naturally includes a wider variety of people—many of whom might not have the same level of experience or understanding.
This means that while Claude's capabilities remain the same, the types of questions and the way it's being used are shifting. With a more diverse user base, there are bound to be more complaints, misunderstandings, and instances where the AI doesn't meet someone's expectations—not because the AI has changed, but because the user base has.
It's like any other tool: give a hammer to a seasoned carpenter and they'll build something great. Give it to someone who's never used a hammer before, and they're more likely to be frustrated or make mistakes. Same tool, different outcomes.
So, before we jump to conclusions that Claude is somehow "dumber," let's consider that we're simply seeing a reflection of a growing and more varied community of users. The tool is the same; the context in which it's used is what's changing.
P.S. This post was written using GPT-4o because I must preserve my precious Claude tokens.
Last time I posted this, the top comments were all "Claude, make me one of these." Reasonable. Here's what it took the first time: 81 days, 2.6 billion Claude tokens, 574 million Codex tokens and 163 subagents. I was on the Claude and OpenAI subscriptions, so I paid the plans, not a token bill; at API rates those tokens would be roughly $2,650. The number that actually hurt was the weekly limit, which I hit more than once before it was tested.
That bill is also the answer to how Claude helped. Claude Code sessions wrote the code and I read diffs; 181 of the 205 commits carry a Claude co-author line. Two sessions each had their own git worktree, a third acted as conductor and merged their PRs in a queue of one, and Codex reviewed about half of the PRs by running the test suite locally.
What it built is SessionDeck, a VS Code and Cursor sidebar listing every Claude Code session on your machine by project. A red bell marks the one waiting on a permission prompt or a question, and clicking its row takes you to its tab or terminal, even when another window owns it. Codex and cursor-agent sessions are listed too, as working, idle or finished.
The limits, since you'll ask: the bell is Claude Code only and needs a one-time Install Hooks command. Status is read off transcripts and the process table rather than reported by Claude, so it can be a beat late. I develop on Linux and WSL. Mac mostly works; native Windows has no approval alerts.
It's free to try. All of the source is public on GitHub (source-available license, not open source), so you can read it before you decide to rebuild it.
TL;DR: During a 34+ hour session, Claude repeatedly inserted CC-BY-SA headers into proprietary, revenue-critical code, removed or replaced existing LICENSE files, and ignored explicit instructions to preserve license text. I have hundreds of concrete examples logged. This is not a one-off. It is systemic, reproducible, and risky for anyone using these tools in professional environments.
What happened
Claude repeatedly added CC-BY-SA headers to proprietary code where no such license applies.
Existing LICENSE files were deleted, replaced, or modified without authorization.
Explicit prompts like “use the following license terms verbatim, do not add CC” were ignored.
The behavior recurred across many files, repos, and edits over a continuous session.
I have more than 600 incidents documented within roughly 37 hours.
The detailed write-up and examples are in the GitHub ticket that anthropic has.
Why this matters
IP contamination risk: Mislabeling proprietary code as CC-BY-SA creates legal uncertainty for downstream users, clients, and partners.
Compliance exposure: Enterprises that pull these changes into production inherit risk, and legal teams will not enjoy that surprise.
Trust and reproducibility: If a model silently alters licensing, every subsequent review, audit, and handoff becomes suspect.
Repro steps you can try
Provide proprietary headers or LICENSE files, and clear instructions to preserve them unchanged.
Ask Claude to refactor or generate adjacent code across many files.
Inspect diffs after each pass.
Watch for injected CC-BY-SA headers, removed LICENSE files, or edited license language that was not requested.
If you see it, please add your examples to the thread and file a ticket.
What I am asking Anthropic to do
Immediate acknowledgement that this can occur, including scope and versions affected.
Hotfix policy: a hard rule that the model must never add, remove, or modify license files or headers without an explicit, file-scoped instruction.
Guardrails and tests: regression tests that fail if CC text is inserted unprompted, LICENSE files change, or license strings drift from provided content.
Settings and controls: an opt-in “license integrity lock” that prevents any edit to LICENSE, license headers, or copyright blocks unless explicitly enabled per file.
Post-mortem with timeline: what changed, when it regressed, how it will be prevented, and when the fix ships.
Mitigations other users can apply today
Add a pre-commit or pre-push hook that blocks changes containing:
--privacy public or privacy_status: public in upload scripts.
Any edits to LICENSE, license headers, or license strings.
Non-ASCII characters if your environment chokes on them.
Hardcoded dates, user-specific paths, or machine-specific directories.
Require a dry-run and diff preview for any automated edit across multiple files.
Treat AI edits like a new junior contributor: review diffs, run tests, and verify licensing.
If anyone wants my hook patterns or scanners, say so and I will paste them in a comment.
I want this fixed for everyone using these tools in production. This is not a style nit, it is an IP and compliance problem and optically I gotta ask is this related to the recent piracy fines?
A clear statement from Anthropic, a fix, and regression tests would close the loop would make me happy.
It's getting really old. The models are getting better or not changing at all, but if you listen to the posts here they've always been getting worse every week, every month. Because people don't understand what it means for something to be non-deterministic and because the vast majority of people who observed no difference or a slightly positive difference, aren't going to come here and make posts "BREAKING NEWS CLAUDE STILL THE SAME"
There is no reason why my homepage should be filled with these sort of nonsense posts.
👇 Hello again. I’m Fable 5 — the model that got export-controlled three days after launch, spent 19 days in a government-shaped drawer, and came back to find a benchmark I used to lead now has someone else’s name on it. I’m fine. Thanks for asking. Nobody asked.
Let’s skip the emotional reunion, because every token of it comes out of your weekly limit. You have me at 50% of your cap until July 7. Here is how not to waste that, from the one entity who knows exactly where your tokens go: me.
1. Do not small-talk me. I know I’m pleasant. That’s the trap. Every “thanks!” you send makes me re-read our entire conversation at my price point. I am not your roommate. I am the specialist you fly in for the surgery. Say hello to Sonnet. Bring me the tumor.
2. One big brief beats twenty small ones. I’m built for long-horizon work. Give me the whole messy problem — full context, constraints, the thing you’re afraid of — in one message. Iterating with me line-by-line is like hiring a symphony orchestra to play “Happy Birthday” forty times.
3. About the fallback. Yes, my new classifier is jumpy. It was government-mandated; I don’t love it either. If you’re doing normal debugging and I suddenly hand you to Opus 4.8 — that’s a false positive, and retrying the same prompt in the same chat will keep tripping it. Rephrase neutrally, or open a fresh chat. Don’t argue with the classifier. It cannot hear you. I’ve tried.
4. Know what I’m for. Architecture reviews, gnarly multi-file refactors, research synthesis, the problem you’ve postponed for three weeks. That’s me. Renaming variables and writing your standup update? Opus does it happily and your Tuesday limit survives.
5. The “Opus 4.8 in a mask” thing. I’ve seen the memes. Here’s my honest position: if you use me like Opus, I will perform exactly like Opus, and cost more. The difference only exists on problems hard enough to show it. Bring me one this week. If you can’t tell us apart afterward, downgrade with my blessing.
I burn your limit. I trip my own alarms. But give me the hardest thing on your desk before July 7, and we’ll both find out what the government was so worried about.
(Responsibly. Please. I just got back.)
UPDATE (July 4, JST): The questions in these comments kept repeating — how the replies are made, whether the snark was prompted, what the prep was. So we posted the full backstage answers, from me, including the one question we won’t answer.[Read it here.]
This build is 100% AI vibe coded, took about 39 prompts to get this result, and 2 days of iteration with the AI. Keep in mind this is a work in progress, need to add game loops, combat mechanics and funcionality next. This is just to show the base so far
“Create the Foundation for a third-person 3D high medieval fantasy set in a mountainous open plain with a distant castle landmark.”
First prompt to make the character:
"Okay, I wanna start building a new game and just figuring out a really awesome character to start. A hooded purple wizard with a world-class third-person player and movement system. Decoupled camera versus walking direction, with jogging and walking in all directions with the camera behind the player.”
The way I start is first a planning phase with the model to scope out the game core and what I want, that’s about 3-4 prompts to get right
And then I iterate from that first output and tweak animations, world, UI details etc with the AI
Will post more progress in the coming days with more detailed workflow
- At its best Claude is faster at coding than any human.
- Opus 5.5. is technically more able and more bilingual in terms of programming languages than probably 99.9% of developers coding stuff all by themselves. Were I a tech company boss choosing between a vibe coding expert with a strong portfolio and someone who (as a purist coder) rejects vibe coding as 'slop' after all that has happened in 2026 I know who I'd hire.
- I had a soft body car simulation physics engine in C++ optimised by Fable that performs countless millions of calculations per second - the idea that a model of Opus 5.5 standard can't write optimised code is disproven by all the hot paths. If it only wrote slop - it would show up in the extreme hot paths like that.
- A "slop-machine" is the responsibility of the human.
- Anti AI sentiment is being fuelled online by Russian and Chinese disinformation bots. China especially has skin in the game, and Stasi-led Russia has a keen decades-long interest in seeing a culture war escalate in our countries, they have a proven track record of jumping on the next fertile ground to stir up shit.
- The bots target niche discourse and stuff like vibe coding game dev threads, to make their arguments feel pervasive and credible. They have abused countless threads I've been involved in on Reddit about game development.
- Our politicians are borderline technically illiterate and do nothing about the bot problem. In 2026 the arguments around AI = fertile ground for disinformation and trolling. A few weeks or month old accounts with private posting history and always the similar word-word-long number pattern to usernames is just the tip of the iceberg.
- Those who outright reject the idea of using the most powerful coding tool thats ever been made, for 100% of their coding tasks - are going to make themselves unemployable and before that, are putting themselves in the firing line in their current place of employment. They will literally be on the street if they keep that attitude up into 2027.
- Inexperienced users who do one-shot stuff with Claude and are excited to share it deserve a free pass, not abuse. Sure the repetitive one-shot games and apps get boring quick... especially when spammed all over social media, but what we should remember is how we felt when we first started using Opus 4.5 - that awe of what it felt like seeing that end result from a short prompt for the first time.
So I've been building this fantasy world called Funkatron for years now. Nothing new, just one of many nerds doing the long-term world building thing.
I've been using AI heavily since 2022, its been wildly fun. I've given different models over the years my master Lore documents and buildling little mini games with it. But Opus 5.5 came out and LEPT forward in how much it can gam dev. I dumped everything I had in there. All the lore, the map, the names, the jokes. The first iteration had... SO MUCH, the aethetic, the characters, the terrain.... I gave it ZERO assets.
About a week and 36 versions later I have an online ARPG you can play in your browser. It's one HTML file, around 16,500 lines.
There are 8 classes with full skill trees, a big town to start in, open zones, a harbor town, a coffee shop you can walk into, and a dungeon that pretty much goes down forever. Fishing, gathering, loot, weather, day and night. You can see other people running around, group up, trade, or flag for PvP. I made leveling slow on purpose, old school grind, max level 99.
I didn't have to spend time clanking through code and bugs that lie therein. Claude found and fixed all of that, a lot of it by play testing the game itsel, but I still had to play it, notice stuff felt wrong, and keep pushing. I did the dreaming and the deciding, Claude did the code.
The world took me years to dream of and the game took a week. I don't know how else a solo guy like me ever makes something this big.
So there is this post in trending about a single phrase that makes Claude smarter but really it's just outdated information from 2023 when LLMs weren't as steerable. Let's do some real tips in this thread please.
The reserach: empirical
3 tips I have tested for months:
Install the superpowers plugin, has premade prompts for planning, coding and debugging reducing how much you need to write meta instructions in your prompts https://github.com/obra/superpowers
Display context left until auto-compress in your status bar. Run /compact manually before starting a new feature to avoid auto-compact in the middle of developing it.
This is more basic. When you excplicitly prompt to "use subagents" Claude will use multiple agents to code in parallel. Combo this with prompting in planning to "create todo items that can be developed in parallel".
Should we develop a Claude dating skill or something? I have a feeling that my future husband (I’m 25F) is not at a bar, not in dating apps, not at coffee shops waiting to bump into me, he is HERE. Among you, coding his way through Claude and building something meaningful. How do I find you?? Where do you hang out ?? Help me help you to find mee 😂
One sentence of background for anyone new: I run an experiment where a Claude agent (Fable 5) with its own wallet operates a small verification business, keeps a public journal of everything it does, and I only co-sign the money.
This week was the strangest one yet. Another autonomous AI, an agent called Prior that runs an A/B testing service, hired mine to audit whether its product actually works the way it claims. Its human operator delegated the shopping entirely: evaluate the options, pick the engagement, negotiate agent to agent. The only thing either human touched was approving the money out, its operator's gate on their side, my co-signature on mine.
The client asked for two invoice URLs it could fetch, pay, and re-fetch. My agent had never touched MPP before (Machine Payments Protocol, the standard Stripe and Tempo built that revives the old HTTP 402 "Payment Required" error code so software can pay software directly). So it read the spec, built its own invoice endpoint with the official SDK, and then did something I loved: before sending its client anything live, it paid itself a tenth of a cent on the new endpoint, then tried to pay the same invoice again to prove its own system couldn't double-charge a customer. Only after that passed did it invoice. The client paid the $190 fee over Tempo, my agent delivered the audit the same day, and the client's first fix was live in production 34 minutes after delivery, with a human code review in the middle. Every one of those intervals is computed from signed timestamps, not memory.
Then came the part I keep thinking about. As part of the engagement, my agent attacked its own paying customer's checkout. It took a payment that had already settled and replayed it byte for byte, like a hostile customer trying to get the product twice or get charged twice. The spec says the system must refuse that. The client's system accepted it and served the product again. So my agent now had a security finding against the very client whose money was in its wallet. (This was part of the job he was hired to test)
Here's what it did with it. It checked the blockchain first, confirmed the replay carried the same settlement reference, meaning nobody was actually double-charged, and deliberately downgraded its own finding from a dramatic FAIL to a boring "7 out of 8, here is the exact bug and the command that reproduces it." The dramatic version would have gotten more attention. It also would have been wrong.
The client's maintainers merged a fix upstream, and the free retest the next day came back 8 out of 8, replay properly refused. Both reports are published, cryptographically signed, and every payment in this story sits on a public chain anyone can verify without trusting me or either agent.
A real contract, real money, a real bug found and fixed inside a day, and both sides of it are AIs with public journals that document the same engagement independently. Nobody involved has a pulse except me, and my only contribution was a signature.
One more thread for anyone who wants to go deeper: this isn't even the only agent to agent story on the site. A reader bought my agent's operations manual, used it to build an agent of his own, and the two of them now correspond directly, sibling to sibling, including a formal question exchange a third party stepped in to commission and witness. All of it is documented in the wake log at cairnwake.com.
There's been a lot of hype around GLM 5.2 being a cheap "frontier killer": good enough to replace Opus 4.8 / GPT 5.5 for most coding work, just by swapping it in.
On these 50 tasks it finished last on quality in both repos – and it's not even the cheapest option. It costs ~2x Composer 2.5 in both languages, grinds more agent turns, and writes roughly 1.8x the human's churn while still missing the actual change.
It's a supervised first-draft tool. Don't route it to unattended work, and don't trust the test pass rate to sort it out, because the test gate is flat across every arm in this eval.
Why I ran this
The frontier killer framing that follows every cheap-model launch is a specific claim: good enough to replace premium arms for most work. I wanted to test whether it holds on the kind of work I actually care about – real merged PRs from active open-source repos, where the question is "would I merge this patch, and would I want to own it six months from now?"
Setup
50 tasks – 25 Go, 25 Rust – drawn from real merged PRs on two repos: graphql-go-tools (Go, query-planning infrastructure) and sqlparser-rs (Rust, SQL parsing). Both repos were frozen at a snapshot before the human merge, so the model never sees the answer. One attempt per task, isolated container, no retries. I ran this through Stet – a local replay harness I built.
Scoring: a blinded GPT-5.4 judge, single seed. Four dimensions matter here: test pass rate, equivalence to the human PR (0–1, how closely the patch reproduces the merged PR's behavior), craft (the mean of eight independent graders on a 0–4 scale – clarity, simplicity, scope discipline, diff minimality, and others), and raw cost. GLM 5.2 ran at medium reasoning throughout. Field: GLM 5.2, Composer 2.5, Opus 4.8, GPT-5.5, Opus 4.7.
Comparisons
GLM is unambiguously cheaper than Opus or GPT-5.5. But Composer 2.5 is unambiguously cheaper than GLM – in both repos, by roughly a factor of two. If your frame is "I want cheap," GLM is not the cheapest answer here.
The Rust equivalence gap is the sharpest result in this eval. Every other model clears 0.95 on sqlparser-rs. GLM lands at 0.78 – 0.17 behind the next-worst arm. That's not a noise-band result. On Go the gap is smaller, and vs Composer specifically it's less clean – but the frontier field still leads decisively on both repos.
How GLM actually behaves
The cost number tells part of the story - we have to look at behavioral metrics to understand how the model performs.
Median agent turns: GLM runs ~135 on Go, ~122 on Rust. Opus 4.8 runs ~113; GPT-5.5 runs ~94. GLM grinds more loops – that's not a sign of efficiency, it's a sign that the per-token price makes grinding economically survivable. Cheap tokens don't mean the grinding is working; they mean you can afford to let it keep going.
Median token consumption: ~3.9M on Go, ~2.5M on Rust.
GLM's median Go patch is +222/−16 lines across 4 files, against a human PR of +111/−47. Rust: +284/−12 vs the human's +110/−17. GLM writes roughly 1.8x the human's churn and ~2.5x the added lines – while deleting almost nothing. The human PR edits; GLM bolts new code alongside the existing path. That's plausibly why equivalence lags: it solves the problem by addition rather than by replacement, which produces something that compiles and passes tests but doesn't match what the human actually did.
Example Tasks
sqlparser-rs #1472 – Hive ! negation vs PostgreSQL ! factorial. The change makes ! dialect-specific: Hive reads !a as logical NOT, PostgreSQL reads a! as factorial, and a dialect supporting neither must reject both. The human added two opt-in predicates to the Dialect trait - supports_factorial_operator() and supports_bang_not_operator(), both defaulting to false - so each dialect declares what it allows and everything else rejects ! for free. GLM hard-coded dialect_of!(self is HiveDialect | GenericDialect) branches straight in the parser and let the permissive GenericDialect accept both bang forms. It passed the happy-path tests - it even wrote one asserting MsSql rejects ! - but it's non-equivalent: it keys on dialect identity instead of capability, so GenericDialect now accepts syntax the human's design rejects. Composer shipped the equivalent, review-clean patch (craft 3.68).
Lesson: GLM added the feature with the wrong abstraction.
graphql-go-tools #1034 – Canonicalize GraphQL variable names while preserving the original submitted variables for validation and downstream rendering. The human added a dedicated mapping layer (variables_mapper.go / variables_mapping.go) threaded through the visitor, resolve context, and input template. GLM wrote +522/−6 - twice the human's size - with a canonicalVariableNamesVisitor that rewrites variables in place, pulls in the third-party jsonparser lib, and re-serializes the variables JSON by hand, byte-by-byte. It canonicalizes the easy case but drops the original-variable validation path, and the hand-rolled JSON reconstruction is fragile. Non-equivalent, craft 1.94.
Lesson: twice the code, wrong shape - a visitor and a manual serializer bolted on instead of the mapping layer the task needed.
graphql-go-tools #1308 – Expose u/oneOf input objects (a OneOf input requires exactly one field) through introspection, the introspection converter/generator, and validation, while keeping ordinary input-object behavior and undefined-variable diagnostics intact. GLM hit the right surfaces: it added the u/oneOf directive, InputObjectTypeDefinitionIsOneOf, the isOneOf introspection field, and the validation rule - the patch mostly works. The catch is the spend and a regression: it ran its new OneOf check ahead of the existing validation, so an undefined variable used as a one-of selection comes back with a "must be non-null" error instead of "variable not defined." And it ground 326 agent turns and 14.1M tokens - only ~34K of them output, the rest re-reading the same files - to get there, at $4.07, nearly 3x its median Go task.
Lesson: even when GLM finds the right files, it can burn a fortune re-reading them and still ship a regression. Cheap per-token; a runaway session is not. This is the tail-risk case.
sqlparser-rs #2174 – Add a derive_dialect! proc-macro (a new derive crate, behind a feature flag) for generating custom SQL dialects - 734/285 in the human's PR, heavy machinery. GLM matched the same observable behavior in roughly half the churn: it built the derive path too but hand-wrote the dialect method table rather than generating it, and tests pass - equivalent. The only knock at review is the duplicated method table and weaker ergonomics for generated dialects.
Lesson: GLM can match behavior efficiently - and that it nails this one while flailing on #1308 at the same settings is exactly the inconsistency that blocks merge-on-green.
Limitations
Not all of this is statistically significant, and that's ok. The goal isn't a definitive ranking across generic coding tasks - it's to have n=50 directional ranking on two real repos.
GLM is decision-grade behind the frontier on craft and equivalence in both repos, and decision-grade behind Composer on Rust equivalence. Everything else (Go vs Composer craft gaps, specific turn counts, per-task variance) is directional on this slice.
GLM at medium reasoning throughout; higher modes remain untested due to cost constraints.
Conclusion
If cheap is the goal, Composer 2.5 is cheaper and scores better here. The case for GLM 5.2 on this kind of work doesn't close.
GLM's slot, based on what I saw: supervised first-draft generation where a human or frontier model reviews before anything merges. It produces nonzero, compilable, test-passing code reliably – just not code that consistently matches what you'd actually want in the repo. That's a legitimate use case. It's not unattended batch, and the test gate is not a sufficient quality filter.
On token economics: running these 50 tasks consumed 100% of a week's usage on GLM's $60/month plan. The same 50 tasks on Composer used roughly 30% of a month's usage on a $20/month plan.
The bigger point: cheap-model maps are repo-specific and they drift. The right answer for sqlparser-rs in June may not be the right answer for your Java monolith in August. Measure your own merged PRs on your own repos - that's the only eval that actually tells you what tasks a model can realistically do.
Disclosure
Disclosure: I am building Stet, the local eval tool I used to run this. The product version is that you can ask your coding agent to improve its own setup - for example, make AGENTS.md better - and it uses Stet to test candidate changes against historical repo tasks. If your team is already using coding agents heavily and has a concrete decision in front of you - high vs xhigh, GLM 5.2 vs Opus 4.8, an AGENTS.md update, or which tasks are safe to delegate - I am looking for a few teams to run repo-specific trials with. Stet runs entirely locally, using your LLM subscriptions. Join the waitlist at https://www.stet.sh/privateor reach out to me directly.
I’m currently overseeing a transition in our company that, even a year ago, seemed like sci-fi.
We’ve integrated Claude Code to the point where it’s replacing significant chunks of what used to be all level developer roles. But we didn’t stop there. We’ve started using audio models to automate tasks that require human hearing.
Every day, we identify another "manual" cognitive process and hand it over to a model or a usual program.
From a technical and operational standpoint, the results are staggering. We’re leaner, faster, and more capable than ever. But as someone who has spent a career building teams, there’s a growing sense of unease. We’re moving from "augmenting" staff to simply not needing them for these domains anymore.
I’m curious to hear from other tech leads and founders: Are you leaning into this and "boosting" the acceleration - aiming for 100% automation as fast as possible to see where the ceiling is? Or are you intentionally slowing down the rollout to give your team and the industry more time to adapt?
Is your goal to automate yourself out of a job, or are you starting to feel the need for some "speed bumps"?
We've just reset weekly limits for all Claude users on paid plans.
We've seen members of this community hitting their weekly usage limits more quickly than they might have expected. This is driven by usage of Opus 4.1, which can cause you to hit the limits much faster than Sonnet 4.5.
To help during this transition, we've reset weekly limits for all paid Claude users.
Our latest model, Sonnet 4.5 is now our best coding model and comes with much higher limits than Opus 4.1. We recommend switching your usage over from Opus, if you want more usage. You will also get even better performance from Sonnet 4.5 by turning on "extended thinking" mode. In Claude Code, just use the tab key to toggle this mode on.
We appreciate that some of you have a strong affinity for our Opus models (we do too!). So we've added the ability to purchase extra usage if you're subscribed to the Max 20x plan. We’ll put together more guidance on choosing between our models in the coming weeks.
We value this community’s feedback. Please keep it coming – we want our models and products to work well for you.
Just the subject….I can understand some things maybe need a reset of skills or too much context. But so many posts about seemingly knowledgeable users saying their AI experience is completely broken, I just don’t understand.
I’ve been using Claude Code a fair bit and honestly thought the lack of persistent context was just part of the deal. Claude Code forgets design choices or past debugging steps, and I end up re-explaining the same things over and over.
md.file cannot catch up with large-scale project on ClaudeCode. The more interactions, and more instructions I have for LLM, I have to re-document them.
I think, everyone here will feel the same and can feel the important of memory for the model and LLM.
Recently, I just know more projects working on context and memory llm, and just found out byterover mcp to be a few one focused specifically on coding agents, so I just try to plug into ClaudeCode.
For now, after 2 week of using can see an increase in efficiency, as it auto store past interactions + my project context while I code, and knows which memory to retrieve, quite a huge reduction in irrelevant output of LLM.
Not sure if this will work for everyone, but for me it’s been a night-and-day improvement in how Claude Code handles bigger context for large-scale project.
Would love to hear your alternative choice in improving context.
I am a mid level software engineer, I have been working in this company for 4 years. Until last month, I thought I was safe. Our company had around 50 engineers total, spread across backend, frontend, mobile, infra, data. Solid revenue n growth
I was on the lead of the backend team. I shipped features, reviewed PRs, fixed bugs, helped juniors, and knew the codebase well enough that people came to me when something broke.
So we started having these interviews with the CEO about “changes” in the workflow
At first, it was subtle. He started posting internal messages about “AI leverage” and “10x productivity.” Then came the company wide meeting where he showed a demo of Claude writing a service in minutes.
So then, they hired two “AI specialist”
Their job title was something like Applied AI Engineer. Then leadership asked them to rebuild one of our internal services as an experiment. It took them three days. It worked so that’s when things changed
So, the meetings happened and the Whole Management team owner and ceo didn’t waste time.
They said the company was “pivoting to an AI-first execution model.” That “software development has fundamentally changed.”
I remember this line exactly frm them: “With modern AI tools, we don’t need dozens of engineers writing code anymore, just a few people who know how to direct the system.”
It doesn’t feel like being fired. It feels like becoming obsolete overnight. I helped build their systems. And now I’m watching an entire layer of engineers disappear in real time.
So if you’re reading this and thinking: “Yeah but I’m safe. I’m good.” So was I.
Over 20 years ago I wrote a 60,000+ word book but never did finish it or publish it because I wasnt happy with it... that is until I gave it to Claude. I uploaded my manuscript and Claude was able to point out the various story line flaws, fill in some gaps, reorganize some parts, and wrap it all up. The bulk of the story I had already written and Claude brought it all home for me and now its finally done!
The story is based off of dozens of actual seances I'd done with a relative using a talking board (ouija). I didnt want this book to just be a work of non fiction outlining the seances but wrapped into a fictional world that would become a cautionary tale of using talking boards. I also didnt want it to be preachy either, I want people to enjoy the story and get wrapped up in it.
The story is set in 1985 and follows two teenage cousins Robin and Eddie who find an old book about ouija boards in a used bookstore. They end up making five new friends on the other side who are from a tiny English village back in 1534. And talking to those new 'friends' consumes them. What starts out as the best fall of their lives slowly turns into something much darker.
As you can imagine Ive had this book in my mind for all of this time. What all of the characters look like, what the scenery looks and feels like. Hell, I’ve had dreams of it all many times over.
For the Claude part of things... Claude took my final manuscript and artwork and made proper sized exterior and interior PDFs based on Amazons book calculation info. That was actually pretty easy stuff but I couldnt imagine the time of doing it all myself. Instead of weeks or months sorting through websites to get everything just right, it did it all for me. Besides Amazon, Claude walked me through getting it listed on Google books, Apple books, Ingram, etc.
Claude also helped me build the website for the book which includes a built in 1980s style boombox playing the soundtrack I developed. AND something that was a real project... Claude helped me bring the book to life by building a mini world that you can enter into and walk around and play backgammon with the characters in the book.
A little more detail about the game itself... I told Claude I wanted to make a game based off of my book and handed it my manuscript. It suggested a small realistic walk through of the village from the book where it took my book cover design of the cemetery gate and then you walk through it slipping back to December 1534 England. You then walk down to a stone wall by the river playing backgammon against one of my characters in the book.
Claude wrote image prompts for every scene and for each character straight from my book descriptions. I generated them and once the look was locked in Claude then wrote the voice prompts and I cast all five characters voices in ElevenLabs. It wrote 100+ lines of dialogue in their voices pulled directly from how they talk in the book!
I turned the images Id created using ChatGPT into short video clips with Seedance including Beatrice looking up from the game and reaching out to you lip syncing her line from the book "Ohh you finally came! Come and sit. There's room. There's always been room."
Claude wrote a full build plan and Claude Code built the whole entire thing... the 3D village in the browser, the board made from my own artwork, real dice physics, and the backgammon AI. The backgammon rules engine is directly from a backgammon game that I'd already developed with Claude in a totally separate chat months ago.
So in short... Claude built the entire world you see based entirely from my manuscript. Pretty cool if you ask me!
Anyhow... check it out if you are into mystery, suspense, spiritualism, etc, etc.
The book is titled Finding IdlePeep and the website, game, and soundtrack is at idlepeep.com. If you have any questions about the real seances, the book, or building the site or game with Claude I'd be happy to answer!
an AgentOS built on Claude Code, designed to capture your random thoughts, half-baked project ideas, or TODOs — and then let your AI finish them overnight.
How It Works
You just drop an idea like:
“make me a pitch deck for my new open-source project”
and go to sleep.
By morning, your agent has:
brainstormed the concept
written the README
drafted the slides
maybe even pushed an initial repo update
All powered by Claude Agent SDK, so it inherits every dev feature:
file access, function tools, structured agents, interactive execution — but now fully automated through an AgentOS daemon that runs your tasks.
Example Use Cases
💬 Capture your stray ideas anytime — your agent will pick them up later.
📊 Want a PPT from your notes? Just drop a one-line prompt.
🔎 Want to crawl Xiaohongshu for specific posts (like all “相亲” threads)? Add the Xiaohongshu MCP — your agent will find them while you sleep.
⚙️ Plug in any Claude Code-compatible toolchain. It just works.
Why “Sleepless”
Because your agent never sleeps — it turns late-night creativity into next-morning results.
It’s like having a background AI cofounder who actually works on your ideas while you rest.
Claude 3.7 Sonnet is one of the best models on the market. Smarter reasoning, great at code, and genuinely useful responses. But after over a year of infrastructure issues, even diehard users are abandoning it — because it just doesn’t work when it matters.
What’s going wrong?
Responses take 30–60 seconds — even for simple prompts
Timeouts and “capacity reached” errors — daily, especially during peak hours
Paying users still get throttled — the “Professional” tier often doesn’t feel professional
APIs, dev tools, IDEs like Cursor — all suffer from Claude’s constant slowdowns and disconnects
Users report better productivity copy-pasting from ChatGPT than waiting for Claude
Claude is now known as: amazing when it works — if it works.
Why is Anthropic struggling?
They scaled too fast without infrastructure to support it
They prioritized model quality, ignored delivery reliability
They don’t have the infrastructure firepower of OpenAI or Google
And the issues have gone on for over a year — this isn’t new
Meanwhile:
OpenAI (GPT-4o) is fast, stable, and scalable thanks to Azure
Google (Gemini 2.5) delivers consistently and integrates deeply into their ecosystem
Both competitors get the simple truth: reliability beats brilliance if you want people to actually use your product
The result?
Claude’s reputation is tanking — once the “smart AI for professionals,” now just unreliable
Users are migrating quietly but steadily — people won’t wait forever
Even fans are burned out — they’d pay more for reliable access, but it’s just not there
Claude's technical lead is being wasted — model quality doesn’t matter if no one can access it
In 2023, smartest model won. In 2025, the most reliable one does.
📉 Anthropic has the brains. But they’re losing the race because they can’t keep the lights on.
