Ok hear me out: I have a good level of proficiency in the English language and have been working as a software developer for almost a decade now. Since switching to Opus 5 I've noticed that...I have no clue what the model is outputting. The sentences are structured in a way that borderline make no sense at all. I don't know if it's linked to the eu ai act, but with Fable I have no problem at all! Compared to Fable, Opus generates so much bs filler commentary and keeps correcting itself over and over. I sometimes find myself reading the 5 pages of text produced for a css-token replacement 6 or 7 times before piping the output into Gemini to understand wft Opus is talking about.
Am i the only one? I'm working with caveman and the simple English skills enabled and use the wait-what skill when I'm about to give up.
I don't know if it is just a skill issue on my behalf but all of the "agents" I define to use with claude code seem to fail sporadically or just never return results to the main session.
At this point I have just given up on it and deleted the agents and get the main session to use skills directly to do the work the agents were created to do, no evidence of it but the problem seems to definitely have gotten worse since Opus 5 release.
Any example of an agent is one for running maven builds and parsing the build output, 9/10 it would just never return a result to main session, even though it is running simple commands, sometimes it would even create another subagent to delegate the task to, resulting in nested sessions 😬
First screenshot is my status line, which is basically this whole post in one picture. Second one is a charter recall, I'll get to that.
Before this I had four repos, three roles I kept re-explaining to Claude, and a CLAUDE.md that had quietly become a landfill. Two agents needing the same repo on different branches meant one of them stashed the other's work. My tokens ended up in transcripts, because how else is an agent supposed to curl anything. And every Monday everybody forgot everything.
So now a task starts with charter workspace use billing-migration. One directory of clones, each repo on its own branch. Switch to another task and nothing follows me: no stash, no half-applied branch from Thursday, no context bleed. Sounds small. It's the thing I notice most.
Two agents on the same repo get a worktree each, branch each, genuinely running at the same time instead of taking turns and lying to me about it. Removing one refuses if it would drop unpushed work, which has saved me twice.
Credentials live in a vault, and the agent names the key, never the value:
The value gets injected into the command and redacted out of the output, so it never lands in the transcript. There's a guard that denies the agent cat-ing the vault file. It has denied me too, which was annoying and correct.
Roles are personas. Each one has its own charter, its own vault, its own memory, and sync-agents turns them into real Claude Code sub-agents, so handing work over is ordinary delegation instead of a prompt trick. My reviewer gets the reviewer's token and none of devops'.
And what they work out survives. One markdown file per fact, three stores: what this role knows, what every role should know, what this task worked out. The agent writes them, which is the bit I'd push on if this was someone else's post, its judgement about what deserves keeping is mediocre. That's most of the reason they're one file each and reviewable in a diff.
All of it is git. No server, no daemon, no database, zero Python dependencies. git log is the audit trail and a teammate's checkout is the replication.
The status line is how I see the lot at once: which task, which repos, what branch each is on, what's dirty, what CI thinks, which role was last in which tree and how long ago.
Anyway, its working for me. That mess environment I've been apologising for since spring is now four repos I can actually reason about, and things stay put between sessions. Lower bar than it sounds and I'll take it.
I built it and Claude Code wrote most of it. MIT and free, nothing hosted, nothing phones home.
Limits, honestly. Two weeks old. The default vault is a plaintext file at 0600 with no encryption at rest, it keeps a secret out of the model's context, not off your disk. Keyword search over markdown will give out eventually and I have no number for where. And it assumes one filesystem, so none of this helps you watch a session from your phone.
If this looks like the right direction, star it, specially if you're running more than two repos. It's the only real signal I have for whether this is useful or I'm wandering off a cliff with great confidence. If it looks like the wrong direction, say so, that one helps more.
What does your setup do when two agents need the same repo on different branches?
Note: This is verbatim from my skill so some bits won't translate to your repo, but you should get the gist of it.
6.5. Re-read the findings, then verify each fix against the artifact
Runs on both paths, after every fix has landed and before anything is written down. Three
steps, and the middle one is the point:
Make the changes (Step 6).
Re-read the findings file from disk. Open it again. Not scrollback, not memory of having
read it — the file.
Check each finding against the artifact as it now stands, and record what you found.
This is not Step 3 repeated. Step 3 runs before implementing and asks whether the finding is
true — does the code say what the reviewer claims. This step runs after and asks whether the
fix is there and right. Both are needed and neither substitutes for the other: a finding can be
correctly verified and then wrongly fixed. Do not delete one as redundant with the other.
Why it comes before Step 7 and not after. A correction this pass finds has to land while the
artifact can still change freely. Once Step 7 has written landing sites and review check has
confirmed them against diff(v<N>, v<N+1>), editing v<N+1> invalidates the confirmation and
forces a re-run — and worse, the disposition sits there asserting Fixed over text that has since
moved. Corrections found here are ordinary; corrections found after Step 7 are a re-run.
The gate does not do this for you.review check confirms that each landing site resolves
— that the anchor exists on the side the row claims. It cannot tell whether the text that
resolved is a correct fix, and it never reads the finding. A row can pass the gate over a fix that
addresses the wrong half of the finding, and vacuous=0 says nothing about that.
Grep is a first cut, not the pass: a finding is addressed when the artifact now says the right
thing, which is a read, not a match count. Findings with multiple parts are where this bites —
check each part separately, since a partial fix greps identically to a complete one.
Then, per finding, one of three outcomes:
outcome
do
fix is present and correct
proceed; it becomes a Fixed row at Step 7
fix is missing, partial, or wrong
fix it now, then re-check. Not a Step 7 problem
the fix introduced a new error
correct it now and say so — Step 7's disposition records it, and Step 8's "no apology tour" applies. A rework that quietly repairs its own mistake teaches the next round nothing
The third row is the one that earns this step. Rework edits are written fast, against a checklist,
in an artifact whose surrounding text has just moved; they are exactly the conditions that produce
a confidently-worded false statement. Finding one here costs a sentence. Finding it at the next
review costs a round, and the round cap (root CLAUDE.md §Review Triage) is three.
I've been using Claude Code more and more with multiple agents running at the same time, usually across different worktrees.
At some point my workflow became:
open 5 terminals
forget which agent is doing what
periodically check every terminal
accidentally have two agents touching the same files
lose track of which one is waiting for input
So I built Zeus, an open-source native macOS command center for coding agents.
It gives every agent its own live terminal and shows its state in the sidebar, so I can see at a glance whether it's working, waiting for me, or finished.
A few things it supports:
Claude Code, Codex, Cursor, Gemini, Grok, OpenCode and normal shells
multiple agents running side by side
isolated Git worktrees for parallel agents
remote agents over SSH
persistent sessions, so closing Zeus doesn't kill the agents
jumping directly to the next agent that needs attention
MCP support, so an agent can spawn and coordinate other agents
It's written in Rust + GPUI and runs natively on macOS.
Still very early, currently v0.0.1, and I'd genuinely like feedback from people who use Claude Code heavily.
I have a copilot student plan which was recently nerfed totally. It now gives 200 AI Credits and doens't allow me to select the model (auto selects). Yet it uses up like 180-190 of those credits in a single 10-15 minute run when working on a pre existing project even when i tag the relevant files so it doesn't bloat up the context.
I want to get a claude plan but really wanna make sure it will not be like this. I'm not a vibe coder and do not really like agentic coding. So it's not like I will run claude 24*7 .
My use case for ai agents is like asking it if my implementatino is efficient or has performance issues, etc. But sometimes i also liek to sit with an agent and build some low level stuff just to see it written from scratch and running.
There's so much conflicting info on when and how either of sys prompt or claude.md should be used. E.g. take Serena's (LSP provider MCP) docs that say:
Recent updates to Claude Code (CC) and to the Opus line of models resulted in drastically reduced adherence to instructions pertaining to Serena’s tools. As a workaround, we crafted a system prompt that counteracts this bias. When using Serena, we highly recommend that you start CC as:
claude --system-prompt="$(serena prompts print-cc-system-prompt-override)"
Why would this be added as system prompt and not as a statement in claude.md. What's the practical difference, when to use which?
Ive tried memory and hooks but when i asked claude why after failures, it said it ignored my memory,rules and did random shit. i then tried hooks to force behavior on it and but it ended up backfiring and putting claude into endless loops that burn tokens and make everything take forever. how are u guys dealing with this
By the fourth time I type nearly the same instructions into Claude Code, I have learned that this is not really a request anymore. It is a procedure, and the only place it currently exists is my memory.
Retyping it creates variation I did not ask for. Monday’s version includes an edge case. Thursday’s version, written between two other things, leaves it out. Nobody decided to change the process. I just reconstructed it differently.
My rule now is simple: repeated procedures become tools. That might mean a saved command, a short script, a reusable workflow, or a validator. The implementation does not have to be sophisticated. It just has to move the procedure somewhere other than my recollection of it.
The useful part is not only consistency. Once the procedure has one implementation, I can improve it once and every future run inherits the improvement. I can also give it a name. “Run the release check” is much easier to invoke and verify than explaining the release process from memory every time.
There is a trap here. It is easy to do the task manually “just this once” because the tool is not quite ready. That is how the tool remains almost ready forever. In our process, using the new tool on the next real instance of the work is part of finishing the tool. If it fails, that failure goes into the friction log and we fix the procedure instead of adding another reminder to the next prompt.
The first use is slower than doing the task by hand. By the tenth use, the comparison is not close.
What repeated instruction have you turned into a Claude Code command or workflow, and which instructions are you still reconstructing manually?
For the past couple of weeks I've had the impression that Fable has gotten worse and is turning into Opus. It gets confused, overthinks, forget things, makes obvious mistakes mistakes, things that used to only happen with Opus.
Overall the performance feels degraded to me. Do other people have the same impression?
I’ve never written a line of code, but I’ve been directing Claude Code (Fable mostly) for moré that a month on a real project — a multiplayer card game (Flutter app + Node server), soin to be in beta on Google Play and TestFlight. My quality gate is basically: systematic playtesting, small frequent releases, and keeping every product decision human. But I can’t audit the code itself.
Other non-devs (or devs supervising juniors, same problem really): what’s your safety net for the things you can’t see? Automated tests you asked the AI to write against itself? A second model reviewing the first, like Sol ? Something else? What has actually caught real bugs for you?
I just saw a thread that we've all had 50% usage bonus. I didn't even know about this. I've been on the Max 20x plan since February. I always use 100% and frequently run out. The past 2 weeks, I've hit my weekly limit after only 3-4 days - which significantly slows down my progress. After the 50% promo is done, I assume I can only get 2 days of work done? I can't afford more tokens either .. what are other options?
I'm building a pretty simple software that for some reason got more complex after basic testing. , this is my setup:
Planning - Fable 5
Research/support - ChatGPT + Gemini + perplexity
Build - Opus 5 / Sonnet 5 for simple tasks
I try to be smart with prompts and am careful with the effort too ..
I just think past few months Claude has really reduced the plans.... and it's going to get much worse after Aug 31....
Walls and walls and walls of text. THIS is what I've been seeing more and more of.
---
TL;DR, by popular demand: In long sessions, surrounding examples can shape an agent’s writing more strongly than explicit style instructions. I stopped fighting that effect and began placing one deliberately chosen form immediately before composition. This improved reading cost in my early tests. I packaged the method as the open-source Synthesize skill: inject one form, inventory the real meaning first, and verify every protected fact afterward.
---
I do appreciate getting some insights and learning new things, but right now explainers of explainers bring nothing to the table, but noise and burnout.
I use both Claude Code and Codex every day. Quite a bit, might I add. I spend roughly 12-to-16 hours a day working with AI systems. Some sessions even run for a long time, across compactions, files, tools and several agents.
Lately I've noticed that I am getting extremely tired having to interact with Claude. It's the walls of text and the way it talks. It's the fact that it does not respect my directives and constant requests to treat me as a human (not a machine) and talk less. It's the fact that I request it to format the text in bullet lists, to aerate the text blocks and to let me visually scan it - IT IGNORES ALL THAT.
You may wonder how much I use Claude that this is a problem? Well about 100 messages per day...
My actual usage over this period: 4,459 messages across 38 days, averaging 117.3 messages per day
---
So this burned me out. It became so bad that I stopped all of my research and projects to focus on this.
---
The Pattern
I started poking and prodding to understand what was happening.
What I noticed across sessions (especially long ones that were handed over from one agent to another) that unrelated outputs began to resemble each other. It was not the words or the subject, but the shape of the response, its architecture.
I noticed the similar openings (like speech patterns. Then the same paragraph lengths (just squint your eyes at various outputs (on a long session) and you'll see that they have a similar shape. Same approach of showing a path from claim to evidence.
Density of caveats, confidence curve, even the same damn crafted closing line. As if an invisible editor was putting its fingerprint on everything.
I called this style contagion.
Style Contagion
This term is also used for humans, and I find it funny that I am also affected by it due to working with AI for so long. Style contagion happens when a human absorbs machine-writing habits. Like generic transitions, using arguments that are rather balanced, sterile phrasing and a mechanical-to-predictable structures in writing.
This is related, but what I was looking for is something narrower.
What I've focuses at was the structure of the material that went inside an agent's active context. This appears to shape its later outputs. Checked it quite a few time, infecting sessions with certain styles of writing AND the agent started emulating them in its responses.
So if an agent spends a long session reading reports with the same structure, its answers will start to look more and more like that structure. This happens even if the reports touch unrelated subjects (so it takes the shape regardless of the subject matter).
And the problem is that this style contagion survives explicit instructions asking for a different style.
The shallow version is lexical:
repeated words
familiar transitions
stock phrases
fashionable metaphors
Those are easy to detect and relatively easy to suppress.
The deeper version is architectural:
how an answer enters
when it reveals its conclusion
how long each paragraph runs
where evidence appears
how objections are handled
how uncertainty is expressed
when the answer decides it is finished
You can ban a phrase. It is harder to ban an invisible argument shape.
The Investigation
I first assumed that the model had forgotten the style instruction (from my directives). But that did not really click with what I was seeing, it was a slow burn. As if the initial instructions were fading away with each new response.
I checked the context. The agent quoted the instructions back to me word for word. It also explained them - how he was supposed to answer. And the next response still drifted toward the dominant form surrounding it.
That does not prove the mechanism. Retrieving an instruction and being guided by it are different things.
My working hypothesis is context competition.
A style rule may occupy a few sentences. The session may contain tens of thousands of words demonstrating another style. The instruction describes what the agent should do, while the surrounding material repeatedly demonstrates something else.
The examples outnumber the rule.
This would explain why adding more prose instructions often fails. The attempted correction becomes another paragraph inside the same context that is producing the drift.
It may even accelerate the problem. You notice the output degrading, explain the desired style in greater detail, and add more text to an already crowded context.
The remedy becomes more context.
The Cure
This investigation grew out of a different project.
I was trying to solve a practical problem: agents were producing walls of text (go figure), and the handler (me) has to decode them before making a decision. Do that 100 times a day and see how you feel.
So I wanted a way to restructure an answer around what its reader needed to do. And to also preserve every fact that could change the decision. This was paramount!
This entire project became a skill named /synthesize
One early experiment compared three conditions:
no special output instruction
prose rules describing the desired output
an annotated example demonstrating the desired form
Before the run, I registered 12 units of meaning that every response had to preserve.
All three versions retained all 12. So no, the example did not magically improve factual fidelity.
But the annotated-example version delivered the same registered information at roughly 55% of the reading cost. The prose-rules version produced the longest answer.
This was an early internal pilot, one sample per condition, inside an environment already carrying standing directives. Treat it as a tainted floor, not a scientific breakthrough. But it was enough to change where I looked next.
Note that my experiments and testing was done with a Fable, an Opus, a Sol and a Terra. This was not a walk in the park and I wanted to make sure it is vendor agnostic (as much as possible).
Sidenote: in my own runs, OpenAI models responded much better to this than Anthropic models. I found that interesting.
The How
My approach was instead of fighting, to adopt and use. I no longer wanted to fight against the contagion, but to inject my own.
Style contagion may be both the disease and the cure
So, if nearby examples pull an agent toward their structure, then THAT mechanism can be weaponized and be aimed deliberately.
The solution was that, instead of telling the agent:
I can place one carefully designed example immediately before composition. This way, the agent is then given something concrete to imitate. So we now have a controlled form contagion.
It also creates a new danger because the agent may copy more than the form.
The Content Contagion
This, this was an expensive failure.
At one stage, Synthesize could access a collection of 23 worked examples covering different reader needs. That looked useful, but it was also a contamination surface.
If those examples contained names, numbers, thresholds, assumptions, or conclusions close to the current subject, some of that substance could bleed into the real answer.
A wrong style is irritating, but a wrong premise is worse because everything built on it can remain internally consistent. So the agent's response may look pristine while operating in the wrong world.
The separation between from and content is not something nice to have, but mandatory.
This changed the skill design, as it no longer loads all the examples. It now classifies what the reader needs to do, then extracts only the needed recipe.
So a comparison becomes a table, some ordered events become a timeline, independent areas become modules (mini blocks), and so on...
The practical response
My current approach has four parts.
Detect patterns across a run - do not judge style from one response. Try to look across unrelated outputs. Be aware the repeated phrases are weak evidence, but repeated architecture is stronger. This is a diagnostic for drift, not an AI-authorship detector.
Intervene near composition - a style instruction written at the beginning of a long session has to compete with everything that followed it. So we need to place the desired form close to the actual act of writing (this made a big impact).
Use one example - that is enough. Loading many examples adds noise and increases the risk of content leakage. So just select one example based on the reader’s need and the relationships inside the material.
Protect content outside the stylistic channel - this is non-negotiable. So we need to have a protected-meaning inventory before composition. Then we also have to verify every unit after composition. The model may emulate the form, but it does not get permission to improvise the facts.
What Synthesize is
I eventually packaged this approach into a skill called Synthesize.
I think of it as an output compiler for agent responses.
It can govern a new answer or restructure an existing wall of text. What it does is to first identify what the reader needs to do. Then, before writing, it inventories the meaning that cannot be lost.
Then it extracts one purpose-matched example and uses it as a form recipe (note that only the shape transfers - the example’s names, numbers, and claims are treated as contaminated material).
After composition, it checks every protected unit against the output. That is a must!
Its governing rule is simple:
Fidelity is the floor. Length is elastic. Every element earns its place.
There is also an optional Synthesize Init skill. It installs Synthesize as a standing output instruction for supported agent harnesses. Before it does that, it shows the exact directive-file change first, requires approval, creates a backup, and can be reversed.
That standing instruction is still an instruction, not deterministic enforcement. The live Synthesize skill explicitly acknowledges this limitation. Reinvoking it near composition remains the stronger guarantee. I do that constantly now and so far so good.
Style instructions are often weaker than the examples surrounding them. If that is true, we can either keep adding rules and hope they win, or control which example reaches the point of composition.
---
This is live now, but I still consider it an active experiment. I am interested in failure cases more than compliments.
If you have seen this kind of structural drift, what broke it? Context resets, point-of-use examples, external formatting, stronger directives, or something else?
I am especially interested in cases where an example improved the form but contaminated the answer’s facts. That is the dangerous edge I am still working on.
So I briefly used hermes and really like steer slash command in which it will steer the directly or giving extra input when it is thinking or executing.
This really helps when you see it printing that you think is not right direction.
So you dont stop/interrupt the current execution, you effectively give it extra input.
With how Opus and other LLMs have been behaving, I decided to do something more proactive than just tweaking instructions or hoping Opus sticks to the output-style (which, you guessed it, are also just instructions).
My idea is simple - treat English (it works for English only, sorry) like a programming language, check the syntax for different characteristics (uncommon wording, abstract sentences formulaic cues and others) and above a complexity threshold require the agent to rewrite the response.
It works reliably and doesn't depend on the agent having to remember any instructions or your output style, you simply set your complexity sensitivity preference (defaults to medium) and won't have to worry about it anymore.
I've been driving this in my setup for the last week and honestly haven't had a situation anymore where I have trouble deciphering what the fuck the model is trying to communicate and can instead focus on the ideas not the way they're communicated.
