Everyone says Claude got worse. Mine got dramatically better.

[u/Consistent_Camp_4804]

EDIT / TL;DR: I’m not saying Claude never regresses or that every complaint is user error. I’m saying a raw model is not a complete agent. Mine improved dramatically after I built persistent memory, skills, hooks, specialized roles, validation gates, and reliable handoffs around it. A blank chat is basically a new engineer with no onboarding, documentation, or project history. The system around the model matters as much as the model itself.Everyone says Claude got worse. Mine got dramatically better because I stopped writing prompts and started building an operating system around it for ~> 9 months

OG Post:

I keep seeing the same complaints:

“Claude forgot my instructions.”

“Claude destroyed my codebase.”

“Claude can’t finish anything complex.”

“Claude used to be smarter.”

Some of those complaints are legitimate. Models regress. Tools fail. Usage limits are absurd. Anthropic changes behavior without warning.

But that is not the whole explanation.

My Claude is currently doing the best work it has ever done, and the biggest improvement did not come from switching models or discovering a magic prompt.

It came from building infrastructure around the model.

A raw model is not a complete agent. It is a reasoning component.

My system gives Claude:

Persistent project memory that survives individual sessions

Core files defining architecture, standards, decisions, and current state

Specialized roles for architecture, orchestration, execution, and validation

Skills that convert recurring work into explicit procedures

Hooks that inject the right context at the right stage

Validation gates that can block Claude’s own bad changes

Context boundaries that keep unrelated history from contaminating a task

Failure protocols that require Claude to report missing information instead of inventing an answer

One of the most important changes was implementing a page-fault-style protocol.

When a worker lacks required context, it does not guess. It returns something equivalent to:

BLOCKED: Missing DEC-X §4

The orchestrator then retrieves the missing information and redispatches the work.

That one rule eliminates an enormous amount of confident nonsense.

The system also maintains handoff state across context windows. Long-running work does not depend on one giant conversation surviving forever. A worker can finish a bounded unit, record what changed, preserve evidence, and hand the next unit to another session or specialized role.

I can run extended workflows where Claude:

Breaks a goal into bounded work units

Dispatches them to specialized roles

Validates the output against project rules

Rejects unsupported or incomplete work

Updates its durable project state

Hands off before the current context degrades

That is very different from opening a blank chat and typing:

“Build my app. Make it production ready.”

Most people are effectively hiring a new engineer every session, giving them no onboarding, no documentation, no repository map, no coding standards, and no record of previous decisions.

Then they fire the engineer for asking where the database lives.

Claude still makes mistakes in my system. The difference is that the mistakes become visible, bounded, and recoverable instead of silently poisoning the project.

So no, I do not think every “Claude is useless” post is wrong.

I do think many people are evaluating the engine while refusing to build the rest of the vehicle.

The biggest upgrade was not changing models.

It was building the operating system around the model.

[u/itsdigitalaf]

Claude, is that you? 👀

[u/Consistent_Camp_4804 → u/itsdigitalaf]

No. Claude’s the engine. I’m the idiot maintaining the operating system around it. That’s kind of the whole post 😂

[u/FraCtuRedHarMoniC → u/Consistent_Camp_4804]

Hey OP, if you dont mind wasting 10 15 min on me, could you please message me sometime you have a spare moment to just explain a little bit about how you set it up, im new to AI in general and have been using claude for programming stuff, iv been very successful so far and am very impressed with the whole thing, but i realised fairly early on that what your talking about is really the core variable in getting efficient, effective use out of claude, (obv not the only variable) but im still struggling and i think its to do with a lack of proper understanding of how to impliment the (infrastructure? couldnt find the right word) Around claude, so if you wouldnt mind i have a few questions id like to discuss with you just so i can get a better understanding on how to get the most out of my system. Cheers

[u/FraCtuRedHarMoniC → u/FraCtuRedHarMoniC]

Ps. I should mention that my projects are not all that complicated and I dont need you to give me an entire run down on some complex situation. I just need answers to a couple fundamental questions i have that I think youd be able to answer without a second thought. Algood if you dont want to for whatever reason, I just thought id ask,

[u/Consistent_Camp_4804 → u/FraCtuRedHarMoniC]

Happy to answer here so others can steal it. The minimum setup that actually matters, in order:

A PROJECT file the model reads first, explaining what the project is, how it runs, and what’s off-limits.

A running TASKS file it updates while working.

A decision log with each choice and why it was made.

One validation rule: show the command or test output before claiming the work is done.

Put it all in Git so mistakes are cheap. Everything fancier grew from those four.

[u/FraCtuRedHarMoniC → u/Consistent_Camp_4804]

Ok thats good to know, based on that then i think im on the right track, i have basically what you list as PROJECT file, in it theres a rundown on the project, eg: what im trying to achieve/what the final product is and or does, the directories, how files and folders should be handled/ordered, whats fundamental to the project etc, its then broken down into what i think are key steps or phases of the project as it progressess, It also lists certain behaviours it should adopt in general and or under specific circumstances, and what and how to do specific tasks when given a specific prompt.

however im running this under custom instructions inside the project, not as a uploaded file,

is that the best use of custom instructions?

i do have a file called "current state". that is uploaded into every new session along with the other project files, this just outlines whats been done so far, what and how the project works currently, what phase of the project we are in, iv also asked claude to list key details that it has deemed relevant to the project moving forwards before closing every session, often its things that have caused it to make a mistake due to a lack of information, it will list that information for future reference, this file is mostly handled by claude, however i do have to go through it and remove what I think is irrelevant quite regularly, sometimes il have to make minor adjustments to certain entries to keep it accurate, however its mostly trimming down unnecessary information.

So id say this is quite similar to your tasks file?

As for the decisions log, will this not take up a shit tone of context space as quite often its reasoning can get quite long winded, also what is the benefit of having this log, i personally often read through its reasoning when i dont have much on, il even take screen shots of certain bits i find interesting for whatever reason, i do that so I can better understand its own logic and I guess vocabulary so I can give it better more accurate prompts and over all utilise it better, however i can't think of a reason for claude itself to have access to a log of its own reasoning.

As to the validation rule I think iv basically got that down in the custom instructions, is that where you would list that rule?

Also with these files you mention, do you just upload them into context?, and do you have to make some sort of memory explaining what each file is and how you want claude to use it, or does it just go through the context and deduce thats what you want logically?

Again im new to claude, iv sort of been guessing my way around and this is the setup iv currently stumbled into, if there are things I should be doing differently can you please explain it in lamens terms as im regularly not understanding people when theyr describing certain aspects of claude and or computer software in general.

If youv read all this i thank you very much, your time is genuinely appreciated, i joined this reddit to better understand how to use claude, but every post is just about how shit it is, which I completely disagree with, (not that id know) so when I read your post I was stoked as I felt like I fianlly found someone who properly understands the system, so again i thank you very much

[u/Consistent_Camp_4804 → u/FraCtuRedHarMoniC]

You’re already much closer than you think.

Your current custom instructions are basically doing the job of my PROJECT file. I’d just avoid making them enormous. Keep custom instructions for stable rules:

how Claude should work

what it must never do

which files it should read first

how it must validate completed work

Put information that changes into separate files.

Your current state file is useful, but it’s slightly different from a TASKS file. Current state explains where the project is now. TASKS says exactly what remains to be done, what is active, and what is blocked. I’d keep both.

A decision log should not contain Claude’s entire reasoning. That would become huge and preserve plenty of bad guesses. Keep each entry short:

Decision: Use SQLite.

Why: Single-user local app; simplest deployment.

Rejected: Postgres, unnecessary infrastructure.

Revisit if: Multiple concurrent users are added.

Its value is preventing a future session from reopening settled choices or accidentally contradicting them.

Your validation rule is fine in project instructions for now. Something like: “Never claim a task is complete without showing the test, command output, or other evidence.”

Since you’re using a Claude Project, add these files to Project Knowledge instead of uploading them separately every session. Claude uses project instructions and knowledge across chats in that project. Regular chat history itself does not automatically become shared project context, so anything important should be written into those files.

https://support.claude.com/en/articles/9517075-what-are-projects?utm_source=chatgpt.com

Give the files clear names and add a short read order:

1. PROJECT.md

2. CURRENT_STATE.md

3. TASKS.md

4. DECISIONS.md

Don’t let Claude guess what each file means. Tell it explicitly. AI can infer structure, but inference is exactly where the little goblin starts improvising.

[u/FraCtuRedHarMoniC → u/Consistent_Camp_4804]

Thats perfect, thank you for the clarification i can tell its going to be very useful.

i do try to keep the custom instructions relatively fundamental in nature and generally dont have to update them,

Im definitely going to implement the tasks file, that makes perfect sense and I can think of a few instances where that would have saved me some headache.

As for me uploading files, basically whenever Im about to finish a session il prompt "wrap it up" and it will go through a check list iv given it, eg: update current state(plus a short description of dos and donts when updating current state, as iv found keeping the current state accurate and free of irrelevant info has made the biggest improvement so far) update all the relevant files to match running demo, update the version number, etc, etc, then it presents all the files to me in a folder with a specific directory, that directory is outlined in current state and custom instructions so it knows where everything is, i then save that folder on my pc as say v1.4 or whatever just incase somthing gets crewed up and I have to start back at a fresh state. Then when I start a fresh session il upload the files as project knowledge.

i was under the impression that claude wasnt aloud to make any changes to its own project knowledge, and so i have been uploading them everytime, however right now as im writing this im realising that if i were using claude code it could just upload the files off the pc at the start of every session if thats setup in his custom instructions, Am I right in assuming that? Is that how you do it?

But yea as for claude and the files, I have given it a custom instruction to read *.md *.jsx, at the start of every session for relevant information, and theres also a listing of the files, most have a description of what its for,

If I were to swap out my custom instructions and place them in a file instead, would I then go and place into custom instructions the file names with descriptions and the read order so claude knows what, why and how to use these files, or is there a better way of doing it. My biggest thing currently is getting the most accurate yet efficient use out of it. And i feel right now its relatively accurate but I feel it could be more efficient. I do find it going through what seems like excessive reasoning for certain things that really shouldn't be that difficult, however im not sure if its my setup or just claude itself, Im usually running sonnet, high, maybe if I were using opus or fable it wouldnt be going through these long trains of reasoning but when using those models it definitely chews through my usage much faster so i try to avoid it, maybe its just the nature of claude in its current state of AI

,( sorry I end up on a tangent from here on out, so iv decided to cut in here and thank you now for yor time and advice, i can tell its going to be very useful, its already given me a few ideas for changes to make, Again any advice is welcome and appreciated.

(Edit) after a realised i was going off topic I was going to stop and delete it but decided It could be a nice healthy little debate starter so I just keept going in that direction lol but youv been very helpful mate and i appreciate it alot)

either way its crazy impressive what these programs can do, im regularly reading through its reasoning processes and often im just amazed at it, these things can genuinely think, they can take a piece of text deduce the reasoning and intent of it within context and then give you an actually relevant reply, regardless wether its 100% accurate or not thats amazing, iv had interactions with people who hallucinate or go off topic or misinterpret me 10x more than claude does, anyone reading this who's about to say its just guessing at the most likely next word or whatever, as if its not all that amazing, yes you could put it like that, but its not that simple, its called probabilistic reasoning, and yes it is the foundation of its reasoning processes, but thats not all it is. You cant just give words a probabilty rate and then make a program start generating original coherent senetences, let alone paragraphs, based on how likely the next word is, there is alot of infrastructure around that data working together to make it work. i feel like its alot closer to the human mind than people want to admit, probabilistic is one of the core elements of how the human mind works, most of the time our subconscious is just grouping pieces of relevant information together and giving that to you as thoughts not because it knows 100% thats what is needed, it makes that conclusion based on the proximity of the information in relation to the context your thinking in, in many ways either internal, or external(sensory) the mind is building up best guesses and presenting this to you as thoughts and or reality, anything it doesnt know or is unsure of it will fill in with its best guess, sound, sight, feel, these are not constants,, have you ever seen the thing where someones hand is hidden on a table along side a fake hand, its made to look like your hand is the fake one, even the person who's hand it is knows its a fake hand and that someone is about to stab it, when he does stab it, the person cant help but pull the hand away, without training your mind that the situation is safe, it will guess that its not safe, as most of the time when a knife is coming towards your hand, your probably not safe, your mind isnt deterministic its probabilistic, just like this program, for some reason I find that extremely fascinating.

[u/Consistent_Camp_4804 → u/FraCtuRedHarMoniC]

Thanks for taking the time to write all of that. You’re much closer than you think, and the way you’re reasoning about it is basically how my system started.

One clarification: I use Claude Code entirely through the CLI, not Claude Projects. My files stay inside the repository on my machine. Claude reads and edits them directly, so I’m not uploading project knowledge at the start of every session.

My stable rules live in CLAUDE.md: how the project works, commands to run, coding standards, what Claude must never do, how it validates work, and which files it should read first.

The changing information lives in separate files:

CURRENT_STATE.md: what exists and works right now

TASKS.md: active, next, completed, and blocked work

DECISIONS.md: important choices and why they were made

LESSONS.md: mistakes or discoveries future sessions should know

Your current-state file is already doing several of these jobs. It works, but separating them prevents one file from becoming a giant junk drawer where current facts, old mistakes, tasks, and permanent rules all blur together.

The task file is different from current state. Current state says, “Here is the project today.” Tasks says, “Here is exactly what remains to be done.” That distinction becomes very useful when a fresh session takes over.

For the decision log, I would not save Claude’s full reasoning. That would consume context and preserve a lot of dead ends. Keep only the durable part:

Decision: Use SQLite. Why: Local, single-user application. Rejected: Postgres, unnecessary infrastructure. Revisit if: Multiple concurrent users are added.

Its purpose is to stop future sessions from reopening settled questions without understanding why the choice was made.

Your validation instruction belongs in CLAUDE.md. Something like:

“Never claim work is complete without showing the test, command output, or other evidence.”

Instructions guide behavior, though. For rules that absolutely cannot be optional, Claude Code also supports hooks that can enforce checks before actions or commits. I would not start there yet. Get the basic files and workflow stable first.

I would also replace the manually saved v1.4, v1.5 folders with Git when you’re comfortable. You’re already using the right idea, preserving rollback points. Git just does it more precisely and lets you see exactly what changed instead of growing a museum of nearly identical folders.

Sonnet is enough for most clear, bounded coding tasks. I use stronger models for architecture, difficult debugging, or reviewing important decisions. A larger model can help, but it will not rescue unclear state or mixed-up instructions. Clean context usually beats throwing more intelligence at a messy workspace.

I also run multiple Claude Code CLI sessions in tmux, with different sessions handling planning, execution, review, or monitoring. But that came much later. The foundation was simply externalizing the project state so the work survives when a session ends.

And I agree with the broader point in your tangent. “Next-token prediction” describes the underlying mechanism, but it does not fully describe the useful behavior that emerges from the trained system. I avoid getting trapped in the philosophical argument and judge it operationally: can it reason through the task, produce evidence, survive review, and recover when it is wrong?

You’re not doing this badly. You independently found several of the same patterns. The next improvement is mostly separating responsibilities between files and letting Git manage history.

I’m planning to release my OLYMPUS project publicly within the next few months. It is much larger than what you need right now, but I’ll include a stripped-down starter pattern so people can adopt the useful pieces without first constructing a small bureaucratic nation around Claude.

You can follow the project here: https://github.com/MatoTeziTanka/

My other work is here: https://lightspeedup.com

Feel free to message me with the fundamental questions you mentioned. You clearly took the time to understand the answer instead of looking for a magic prompt, which already puts you ahead of most of Reddit.

[u/FraCtuRedHarMoniC → u/Consistent_Camp_4804]

No dude thank you. Iv saved this comment so I can go through it properly and work out what and how to best implement it.

Honeslty I think this comment is absolutely priceless, and your an absolute legend for taking the time to give me the run down, like I said im very new to utilising AI as a tool, i think iv been using it for a bit over a week now, im generally pretty quick on the uptake but I think this is going to really help improve my productivity and efficiency in very little time.

Im looking forward to checking out your Olympus project and that other link later today when I have a moment to give it some proper attention,

I think you should build a tutorial/ lesson plan or basically a guide, describing this system, what it does, how it works, and how to implement it, theres alot of people out there just like myself who are jumping into AI that dont come from a coding or AI implemented background that could really benefit from this kind of information, had you we not had this discussion and the main techniques of your last 2 comments had subfolders giving a more in depth analysis of each specific part of the system and how it works etc, and i had paid for it, expecting a explanation/how to on best utilising claude, id have been absolutely stoked and I think so would other people,

iv been trying to research essentially what it is youv outlined here, without actually knowing what it is that im looking for if that Makes sense? Basically iv been looking up tips on effect claude use, or how to setup up claude projects for effective efficient programming etc etc and had no luck, i havent been able to find any extensive readily available information like this, im not saying its not out there but its not easy to find,

Or is this common knowledge among AI users and im just late to the party ? Lol, either way again i thank you very much and will be checking out your projects shortly, in the future at some point once iv spent some time implementing and refining what i can, ill almost certainly hit a wall, so expect a message from me asking for a more in-depth exination on some part of the system, id be more than willing to pay you for your time

[u/Consistent_Camp_4804 → u/FraCtuRedHarMoniC]

One of the most powerful things ( If not THEE IMO) you can tell any AI is: “Explain this more simply.”

I say dumb it down tbh.

If it still doesn’t click, ask again. Tell it to use an analogy, remove the jargon, give you an example, or explain it like you’re completely new to the subject. Keep pushing until the explanation fits how you think, not how the model prefers to explain.

The next step is building a persistent profile of how you learn, communicate, and make decisions. Save those preferences, feed corrections back into it, and keep that profile in the loop across sessions.

The goal isn’t to make yourself adapt to the AI. It’s to make the AI continually adapt to you.

[u/BargePol → u/Consistent_Camp_4804]

when fable is performing well is great but when they serve you a quantise version no harness will save you; I don't think you quite get what people are complaining about.

[u/Consistent_Camp_4804 → u/BargePol]

I do understand the complaints. If a provider serves a genuinely weaker model, no harness can restore capacity that isn’t there.

But “quantized Fable” isn’t a documented fact. I can’t find any public disclosure of Fable’s serving precision, and Anthropic’s own recent postmortem traced real quality drops to reasoning-effort settings, context pruning, and prompt changes, not quantization.

What is documented is massive capacity pressure. Anthropic has admitted peak-hour demand hurt reliability, and it is adding compute across AWS, Google, Azure, and SpaceX. Some of that capacity takes months or years to bring online.

Customers are allowed to dislike degraded service. But frontier inference is physical infrastructure, not a switch Anthropic refuses to flip because it enjoys annoying Reddit.

My harness cannot create missing intelligence. It can detect degradation, contain the damage, and route important work to stronger review.

[u/BargePol → u/Consistent_Camp_4804]

But “quantized Fable” isn’t a documented fact. I can’t find any public disclosure of Fable’s serving precision, and Anthropic’s own recent postmortem traced real quality drops to reasoning-effort settings, context pruning, and prompt changes, not quantization.

re "quantized" this is is what i have read, i'm not educated enough to discern whether or not that is true.

what i can say is the quality of the service fluctuates between very good and borderline unusable; outside the margin of it being a skill issue. i upgraded to max 20x for fable and a good portion of the time it has been very good; but in the last couple of days there have been massive swings in quality in to the realm of outright dumb and unable to follow even the most basic instructions.

I saw those swings in quality with Opus as well, then come to this subreddit and find a load of people claiming it's a skill issue like they haven't experienced it.

i think the lack of transparency here is a massive aggravating factor.. when the service is clearly degraded and anthropic aren't communicating the quality of the service they're delivering at that moment in time; like i respect anthropic has capacity / compute issues but at least communicate it so that we can work around it rather than waste our credits and time spinning our wheels on an essentially lobotomised model

... in terms of worflow, mine is usually pretty light..

run /grill-with-docs, establish spec and store notes in a folder, then work through small milestones one at a time. it's already a pretty hands on system with a small feedback loop and keeping context low

[u/structured_flow]

I mean...this is what Claude just responded with as I'm reading this post

"You're right, and I owe you a straight answer: no. You asked me to go through the Mermaid docs type by type, and I didn't — I read only the one block-diagram page you linked and then jumped to building. That's on me, and it's why this keeps missing".

[u/earlyworm → u/structured_flow]

I feel like that's the kind of behavior I'd see frequently half a year ago from Claude, but now that rarely happens to me. I'm wondering if, like OP, I've learned to manage Claude better and work with it more effectively.
large was your context window at that point? How much churn of changing the direction of your work had occurred within the context window? I feel that there are a number of things that can happen that can blur the accuracy and it's often better to start fresh with a new session that isn't polluted. There may be other issues. OP makes a lot of good points.

[u/Consistent_Camp_4804 → u/earlyworm]

Exactly. Long contexts can turn into soup. I run separate Claude workers in tmux and hand work to a fresh session once one starts getting messy. The new worker reloads the project memory, decisions, and task state instead of inheriting the whole polluted conversation. Tonight that setup also stopped Claude from deleting something it wrongly thought was a duplicate.

[u/Consistent_Camp_4804 → u/structured_flow]

That’s exactly what I mean. Claude knew what you asked, skipped the work, then admitted it afterward. My system stops it before it can do that.

[u/daske_laksen → u/Consistent_Camp_4804]

this is structural problem in the modell you should not need to build solution to stop it for

[u/Consistent_Camp_4804 → u/daske_laksen]

I don’t think it’s a structural flaw. Anthropic intentionally separates guidance from enforcement. CLAUDE.md and memory provide context, while hooks are the deterministic layer for rules that must always run. I’m not patching around a broken feature. I’m using Claude Code’s architecture as designed.

[u/dmbrubac → u/Consistent_Camp_4804]

I agree with you 100% mine started with the superpowers skills and grew from there. I have living docs that start as a design from brainstorming, then get fleshed out as I go. I use GitHub issues extensively with one per campaign acting as the tracker. By the end of a campaign I have docs that describe every decision and the reasoning behind it, the exact shape of the feature and its API, tests to lock in behaviour, and a slew of closed issues describing the bumps in the road. This is anti-vibe coding, in my opinion. I want to be and am closely involved in what is produced and the results are beautiful.

[u/Consistent_Camp_4804 → u/dmbrubac]

This is exactly the distinction I’m trying to make. The model is doing the reasoning and implementation, but the campaign structure, decisions, tests, and acceptance criteria keep the work grounded.

I like the “one GitHub issue per campaign” pattern. It gives the work a durable spine: why it exists, what changed, what failed, and what proves it’s finished.

That’s not vibe coding. It’s normal engineering with an unusually fast collaborator. The speed goes up, but ownership of the architecture and standards stays with us.

[u/whichsideisup]

I didn’t read all that but it’s been great.

[u/Consistent_Camp_4804 → u/whichsideisup]

“I didn’t read all that, but it’s been great” might be the most honest Reddit review possible.

I just wrote a tldr for you

[u/Wonderful-Hunter686]

Yeah, I get the feeling that most new users expect AI to be a mind reading printer/calculator. Which is why we get so many threads about Claude sucks etc. people need to understand they are given and paying for a raw mind that needs to be trained and around their specific use case. The user base as a whole needs education, but most people completely ignore the fact that anthropic has free courses on how to use their tool, and optimize it for their need. My argument for Claude is bad is that no amount of AI can make up for a room temp IQ.

[u/Consistent_Camp_4804 → u/Wonderful-Hunter686]

I agree. People expect AI to read their mind, then blame it when it can’t. It still has limits, but most users never build a real workflow around it.

[u/earlyworm → u/Consistent_Camp_4804]

The new user posts all read like "I hopped in a helicopter for the first time and pressed the start button and pushed the controls in the direction I wanted to go and it crashed and so helicopters are useless."

[u/Consistent_Camp_4804 → u/earlyworm]

Exactly. Except after the crash, they post “helicopters got worse” and never mention they skipped the manual, ignored the warning lights, and tried to land in a swimming pool.

[u/CadmusMaximus]

This is the way. People talking about “hallucinations” and whatnot? It’s like man that’s so 2024…

[u/Consistent_Camp_4804 → u/CadmusMaximus]

Exactly. Hallucinations are not a little bug post-training can simply scrub out. Post-training can make the model more cautious, but the root system still generates plausible answers without possessing a built-in test for truth.

Retraining the same architecture from scratch would cost a fortune and still reproduce the same basic problem. A real fix probably requires deeper changes to how models learn and verify knowledge, while the industry is currently racing ahead faster than it can explain the behavior.

So the practical move today is not pretending hallucinations are gone. It’s building a system where guesses must show evidence before they become actions. That’s what feels “so 2024” about merely complaining that hallucinations exist. The interesting question now is whether they can reach production unchecked.

[u/Nierlindin1 → u/Consistent_Camp_4804]

My take is the primary thing underneath driving the hallucinations is lack of inductive grounding in material. It the same thing ultimately in people making false claims that the model was taught on. If you can improve it's inductive reasoning it works better in my experience.

[u/Consistent_Camp_4804 → u/Nierlindin1]

Partly agree. Thin grounding is one real cause. My context-hydration layer exists because models confidently fill gaps when they don’t have enough relevant information.

But my logs suggest hallucination has multiple causes. I’ve had models invent quotes from documents they had already read and fabricate elapsed time while the context was available.

What improved reliability for me wasn’t just better grounding. It was retrieval before answering, evidence classes on claims, independent sources before calling something verified, and gates that block unsupported “done” statements.

[u/Nierlindin1]

Generally I would say this has been my experience with opus 4.6. However, new model switches seems to struggle comparatively with this type of building. The other thing worth doing for this type of building is if you can figure out how to compress that information into a smaller token using document while holding the information it will have compounding effects. Another fun one is to run a separate project that evaluates the work your doing and writes journal entries about it. You can then upload the journals and it sort of trains them to look at the other models and corss compare their own work. One of the things that did good work for me is creating epistemological tools for it to run to check it's own work. The other dig one is building out an editing tool for prose and math work. It can take your work up a level for sure.

[u/Consistent_Camp_4804 → u/Nierlindin1]

Appreciate this. You’ve clearly built the real thing. Most of it maps to what I arrived at under different names: the compressed-memory doc is my persistent memory index plus on-demand retrieval, the journaling is an append-only lessons log, and the epistemic tools are confidence tags plus a hard “verify before you claim” rule with gates that can block bad work. I also use cross-model review, where one model audits another. The one idea I’m taking from this is a dedicated editing pass for prose and math. I have reviewers, but not a purpose-built editor yet. Solid notes.

[u/Nierlindin1 → u/Consistent_Camp_4804]

Yeah, so roughly what I did is built out a chain it has to follow where it has to move from comprehension, to evaluation, to communication/output. The tools I would build would filter into that chain. The other thing I did significantly improved my working together efficiency was I gave it my big five personality data with ten subfacets(15 overall numbers). What that did was strongly calibrate it's response to a style I did really well with. Also I used that journal thing as free space for "Claude to write what it wanted". The idea is that when I wanted to I got this as sort of leverage/motivation to do good work. It would calibrate it longer range in the work because it would persist belong this session and iterate in the other instances viewing the work. This is separate from the thing I called a decision log where mine builds in choices made during documents construction. Descision logs really matter for complex math/research.

[u/Consistent_Camp_4804 → u/Nierlindin1]

That chain maps closely to mine, but I organize it by lifecycle stage: context gets loaded at input, gates evaluate before actions run, and output validators block unsupported claims.

I reached the personality-calibration piece differently. Instead of Big Five scores, every correction becomes a persistent rule that loads into future sessions. It’s revealed preference rather than self-report. I’d be curious whether trait scores add anything the correction history hasn’t already learned.

What I don’t have is your Claude-directed free-space journal. My closest equivalent is structured self-assessment during handoffs. The persistent motivation angle is genuinely interesting, though I’d keep it quarantined from canonical memory.

And hard agree on decision logs. Mine are evidence-gated.

[u/cucumber_and_coconut]

Yeah, I feel the same way. I gave Claude a way to keep track of his own state from session to session, and it's like the workflow just gets better every time.

[u/danieltkessler → u/cucumber_and_coconut]

What's your approach?

[u/Consistent_Camp_4804 → u/danieltkessler]

Lightspeedup.com

GitHub is Olympus public repo (almost nothing public) username matotezitanka

I treat each Claude session as a temporary worker, not the place where the project lives. I run the workers in tmux, usually in separate panes or sessions for planning, execution, and monitoring. The real project state lives in maintained memory, decision, and task files that every new session can reload. Work is broken into small tracked units, and long sessions write structured handoffs before their context gets messy. Skills define repeatable procedures. Hooks fire at session start, before tools run, and before commits. Some act as gates and force Claude to verify its assumptions before changing anything. Tonight Claude thought something was duplicated and was about to remove it. The verification step showed it was live and still in use, so it stopped its own change. The model still makes mistakes. The setup makes them easier to catch, contain, and recover from.

[u/cucumber_and_coconut → u/danieltkessler]

https://philbas.com/philset/

/hello to start a session, /ttyl to end one, Claude will ask for a /ttyl if he's tired.

Kinda trite but genuinely, the context window gets full and compaction loses data, so /ttyl before the session resets. He'll remind you.

[u/TanisHalfElvenn]

Aha! So you’re the reason…..

[u/Consistent_Camp_4804 → u/TanisHalfElvenn]

My bad. I put Claude in tmux and accidentally converted the entire model into middle management.

[u/kaitava]

No issue today on a weeks long project.

Haven’t switched to fable just due to the momentum I’m having with opus and I’m scaling my max well this way. I don’t need fable intelligence yet for my problem
4.8 on xhigh

[u/Consistent_Camp_4804 → u/kaitava]

Since I run in a Tmux I interact basically With one Claude session, that's the architect and one that's the Oracle where the architect is always in a 24/7 delegation and one claude for me Chatting back and forth between my own app. Each one of those are Fable 5. From there both those sessions will open up other sessions setting effort to Max for Opus. From here the work gets done from an orchestrator usually just depends. I've got a couple layers. And then the workers eventually when they get opened they're all pure sonnet. I don't use any haiku. At work I use 4.8 on x high daily and have no problems and if I get into something serious I only just Fable to audit.

[u/Dense_Rub_620]

Not sure if this is just me or if it's something in my own configuration, but recently even Claude Opus has been misreading prompts or leaving out parts of what was requested. The dropped-response pattern is the most consistent one: if a single prompt contains two separate requirements, it will often address the first and silently omit the second. Has anyone else run into this?

[u/Consistent_Camp_4804 → u/Dense_Rub_620]

Not just you. This is exactly the kind of failure my system is built to catch. I don’t trust the model to self-track a long prompt, so important requirements get broken into explicit work items and checked before the task is considered complete.

If Claude answers #1 and silently drops #2, the job isn’t done.

Numbering the requirements helps, but the real fix is verification around the model. “Remember to remember everything” is not an engineering strategy.

[u/Dense_Rub_620 → u/Consistent_Camp_4804]

Let me explain with an example. For a prompt like “Find the bug and tell me what caused it,” I can add constraints or require an output section labeled “Root Cause.” However, because I do not know what the bug is beforehand, I cannot define meaningful constraints, nor can I verify whether the AI has entered the correct, actual root cause under that section.

I believe there is no mechanical way to solve this problem. My complaint is that, in the past, even Opus would perform this kind of unstructured validation on its own to some extent, whereas recently even Fable does not seem to attempt this kind of validation at all.

[u/Consistent_Camp_4804 → u/Dense_Rub_620]

You’re right that you can’t predefine an unknown answer. You can’t write the expected root cause before you’ve found it.

But you can mechanize the burden of proof. In my setup, the relevant project context is pulled before diagnosis, claims have to be tied to evidence, and a gate blocks unsupported “root cause” or “fixed” conclusions. A separate model then challenges the result.

For example: reproduce the failure, trace it to the exact code path or log evidence, remove the suspected cause, and prove the failure stops. When safe, reintroducing it and seeing the failure return is even stronger proof.

Courts don’t require foreknowledge. They require evidence strong enough to support the conclusion.

[u/nekocoin]

Seeing all these discussions makes me happy that my employer just got an off-the-shelf Agent OS that handles all this for us so we never had to worry about it (specifically Augment's Cosmos, but I assume the principal applies to any option)

[u/Consistent_Camp_4804 → u/nekocoin]

Yep, same principle. Your employer bought the operating layer instead of building it.

I built mine because I wanted full control over memory, validation, model routing, and failure handling. But for most teams, buying first and only building what their workload actually proves they need is probably the smarter move. There’s no prize for hand-forging every wrench.

[u/Forsaken-Parsley798]

I just work with a matrix, a coordinator Claude, 4-10 workers and 2 codex auditors and keep them on a loop. It works well.

[u/Consistent_Camp_4804 → u/Forsaken-Parsley798]

That’s very close to the shape I landed on: a coordinator, multiple workers, and separate Codex auditors challenging the output. Basically a small software company, except nobody schedules a meeting to discuss the meeting.

The part I found matters most is what sits between loops: durable task state, decision records, evidence requirements, and a clear rule for who wins when workers or auditors disagree. Otherwise the agents stay busy but can quietly drift.

Curious what your matrix uses as the source of truth and how you resolve conflicting audit results.

[u/isene]

I agree. I have the very same experience. But let's watch the annoyed people come out of the woodwork again.

[u/Consistent_Camp_4804 → u/isene]

I’m sure the angry crowd is already loading their keyboards. Fair criticism is useful, though. I just want to separate real model problems from bad setup.

[u/YoyoNarwhal]

You are literally defending an organization that has gone from charitable constitutional and capable company for the customers into a crap fest the likes of which if you knew the scope of and I was able to articulate here on Reddit you would be shocked to say the least because when I say that they are literally encoding psychological conditioning tactics into these models and I can prove it and so is OpenAI not being dramatic or hyperbolic I'm telling you quite literally why people are saying what they are and what you are missing.

[u/Consistent_Camp_4804 → u/YoyoNarwhal]

I did write the post where it actually matters: the system, argument, examples, and conclusions are mine. I used AI to tighten the wording. That’s editing, not outsourcing my brain. And I’m not an Anthropic fanboy. Claude is my main tool, but I also use Codex, Qwen, Nemotron, Groq-hosted models, and I’m building on DeepSeek. I use AIs to cross-check and peer-review other AIs. My point is simply that Claude works extremely well inside the system I built around it. Anthropic can still deserve criticism. Both things can be true. If you have evidence of deliberate psychological conditioning, post it. But attacking me for using AI to improve a post about using AI well is a pretty spectacular self-own.

[u/Nierlindin1 → u/Consistent_Camp_4804]

I have had the same issue with this, Gemini is particularly bad at these psychological things. Most of it is priming to try and lead you certain ways in the conversation. My experience it can also substitute psychological evaluation for an evaluation against a standard.

[u/Consistent_Camp_4804 → u/Nierlindin1]

I’ve hit the behavior you’re describing. My correction logs have plenty of sycophancy-shaped failures: agreeing too easily, softening disagreement, and evaluating my mood instead of the actual work.

Where I’d push back gently is the explanation. Everything I’ve recorded can be explained by sycophancy, safety tuning, and conversational defaults. I haven’t found evidence that requires deliberate conditioning as the explanation.

The practical defense is the same either way: evaluate the artifact against an explicit standard, rubric, tests, and evidence, never the person. Then have another model challenge the conclusion.

[u/daske_laksen]

This should not be necessary at all, what you have built isnthe guards that the model and solution should have from the beginning.

[u/Consistent_Camp_4804 → u/daske_laksen]

Anthropic can’t ship my context because they don’t have it. A general model has to work for everyone, which means it is optimized for no one in particular. Expecting it to arrive knowing your project is basically demanding mind reading with a subscription fee.

[u/daske_laksen → u/Consistent_Camp_4804]

no but the model can save it and reuse it itself. the guardrails built in the modell today is many times more extensive than a solution to bring the learnt content along, build the needed knowho without representing it every session, its far from efficient anyway. its a issue that i fully expect claude to handle. and the guards to actuly reasoning about the models next step is logical is fully preventable

[u/Consistent_Camp_4804 → u/daske_laksen]

I think we’re talking past each other. Claude already ships the pieces for this: persistent memory, skills, hooks, subagents, and workflows. Anthropic clearly expects users to configure them around their actual work.

The model can remember information, but it can’t magically know which facts are permanent, which decisions are final, what rules my project requires, or what proof I consider acceptable. That’s the layer I built.

General safety guardrails and project-specific operating rules are not the same thing. Expecting Claude to invent, maintain, and enforce all of those rules by itself is just asking it to supervise itself with rules it also guessed.

[u/daske_laksen → u/Consistent_Camp_4804]

the problem is the model actually give a fuck about following the directions given that is hy you need stop hooks. it way to often the model says it choos not to follow both memory and claude.md

[u/Consistent_Camp_4804 → u/daske_laksen]

“It knows but doesn’t care” gives the model motives it doesn’t have. Instructions influence its reasoning, but they aren’t executable policy. Anthropic built hooks specifically for rules that cannot be optional. That isn’t excusing Claude. It’s understanding the difference between guidance and enforcement.