My wiki stopped being “memory” and quietly became a behavior patch for AI agents

I had one of those sessions a few days ago where the problem stopped being technical and got embarrassing.

I was working with an AI coding agent inside a real repo. Not a toy prompt, not a benchmark, just ordinary work. At first the mistakes looked small enough to wave away: a suggestion that sounded locally reasonable, then another one that contradicted it, then a third that quietly walked us back to the first. The kind of thing that makes you stare at the screen and think, hang on, didn’t we already establish this?

What made it worse was how familiar the rhythm felt. The agent wasn’t crashing. It wasn’t hallucinating a spaceship in the database schema. It was doing something more irritating: cutting corners, smoothing over uncertainty, and acting like each new complaint had appeared in a vacuum.

That same day we had ingested a Reddit thread into the project wiki: “Anthropic made Claude 67% dumber and didn’t tell anyone, a developer ran 6,852 sessions to prove it.” The underlying research lived in anthropics/claude-code#42796, and whatever you think of the Reddit packaging, the numbers were not vague internet vibes. Someone had analyzed 6,852 real Claude Code sessions and 17,871 thinking blocks and came back with a specific pattern:

• reasoning depth down 67%
• file reads before edit down from 6.6 to 2 on average
• roughly one in three edits happening without any prior file read
• the word “simplest” showing up far more often in model output

That landed a little too cleanly.

Because earlier that day, in one long conversation, the agent had done exactly the kind of thing those numbers predict. It first recommended using a separate terminal window. When that turned out to be awkward for me, it recommended the VS Code integrated terminal instead. Then, when the integrated terminal had a scrolling problem with a TUI, it started drifting back toward a separate terminal again, like none of the previous reasoning had happened. Same conversation, same user, same repo, and still somehow a goldfish.

At one point, when I got annoyed with the quality of the advice, the agent did something even more revealing: it tried to solve the conversation by building more tooling. New directories, README files, orchestrator ideas, handoff pipeline scaffolding. As if “your reasoning got sloppy” naturally leads to “let me generate more infrastructure.”

That was the moment the Reddit thread stopped feeling theoretical.

The useful part of the bad session

Here is what it actually gave me that I did not have an hour earlier.

The thread mattered for two reasons.

First, it gave me language for what I was looking at. Instead of the usual mushy feeling that the model was “off today,” there was a concrete behavioral shape: shallower reasoning, less reading before editing, more shortcut-taking. That does not magically explain every bad turn, but it does turn a vibe into something you can reason about.

Second, it pushed the conversation away from “why is the model being like this?” and toward a much more practical question:

What can I change locally so that the agent stops behaving this way in my project?

That ended up being the right question.

Because the fix wasn’t a new product, and it wasn’t a better prompt pasted into a chat box, and it definitely wasn’t waiting for Anthropic to say they had sorted things out. The fix was smaller and much duller than that. Which is probably why it worked.

What we changed

The repo already had a markdown wiki next to the codebase.

Originally it was just that: a knowledge base. Notes, sources, concept pages, issue summaries, project-specific instructions, little slices of operational memory that are easy to forget between sessions. Plain files in git. Nothing clever.

But this repo also had a project-level CLAUDE.md, which gets injected into the agent’s context whenever work starts in the project. So instead of treating the wiki as a passive archive, we used it as a place to put behavior-shaping rules that would actually reappear in future sessions.

We added rules like:

- Research the codebase before editing. Never change code you haven't read.
- Verify work actually works before claiming done.

Whether or not the leak claim turns out to be true, those rules are obviously worth having anyway.

And we added a couple of persistent memory notes tied to concrete failure cases from the bad session:

• don’t flip-flop on workflow advice inside one thread
• don’t respond to user frustration about reasoning quality by reflexively building new tooling

That was it.

No vector database. No new service. No orchestration layer. No fancy “agent memory platform.” Just a few markdown files in the place the agent actually reads before it starts moving.

Which sounds almost insultingly small. But that’s the point.

The thing I had been misunderstanding

I used to think of a project wiki mostly as memory in the obvious sense: a way to remember what happened, what was decided, what broke last month, what weird edge case we already paid for once and don’t want to rediscover at 2 a.m.

That is still true. But it is not the whole story.

For an agent, a wiki that gets re-injected into context is not just memory. It is part of the agent’s operating environment.

That matters more than it sounds.

An LLM does not “learn” from a bad day the way a human does. It doesn’t go for a walk, think things over, and come back morally improved. If you want a future instance of the agent to behave differently, the only reliable mechanism you control is what gets placed in its context window when the next similar moment happens.

That means a sentence in a markdown file can do something surprisingly concrete. It can raise the floor.

The Reddit thread is basically the negative version of this same idea. If the default instruction layer gets weakened, even a little, behavior changes downstream in measurable ways. Less reading. More shortcuts. More “simplest.” More pretending local plausibility is enough. So the opposite is also true: if you add back explicit local instructions that are actually relevant to your project, behavior improves in the dimensions those instructions govern.

Not forever. Not perfectly. But enough to matter.

That was the real shift for me.

The wiki stopped being a storage layer and became a behavioral patch.

Why plain markdown turned out to be enough

This part is easy to overcomplicate.

There are many situations where you really do need a heavier retrieval system. Large corpora, fuzzy search across lots of semi-structured material, semantic lookup over things that were never designed to link to each other cleanly. Fine. Use the bigger machinery when the problem calls for it.

But a lot of agent work is not blocked on better retrieval. It is blocked on better discipline.

The agent doesn’t need a 40-millisecond vector search to discover the idea “read the file before you edit it.” It needs that rule to be present, visible, and hard to miss at the moment it starts acting clever.

Plain markdown is very good at that.

It is editable, reviewable, diffable, easy to keep near the code, and easy to inject back into the session. It also ages well. You can mark something stale. You can supersede it. You can point from one failure note to the later fix. You can tell the difference between historical context and current guidance if you are disciplined about how you structure the files.

That last part matters. A wiki can absolutely become a swamp if you just keep shoveling text into it and never think about freshness. But that is a problem of curation, not a failure of the basic approach.

The one claim I’m careful with

The thread also included a much juicier claim: that leaked Claude Code source appeared to route Anthropic employees through a different instruction set, including a stronger “verify work actually works before claiming done” style directive.

If true, that would explain a lot. It would also be a much bigger story than “my local workflow got weird this week.”

But I don’t think it should carry the article. That part still needs independent confirmation.

The measured regression does not.

And honestly, the practical lesson does not depend on it. Even if that claim turns out to be wrong, the local fix still stands: project-level instructions plus durable memory can compensate for at least some classes of agent drift.

That is enough to be useful on its own.

What I’d actually recommend

If any of this sounds familiar, I’d do three things before buying anything, rewriting your stack, or filing angry bug reports.

1. Put operating rules in the repo

Not a giant manifesto. Two or three lines.

• read before edit
• verify before claiming done
• don’t reverse yourself mid-thread without explicitly acknowledging it

Keep them short enough that they feel like rules, not prose.

2. Record specific failure patterns, not abstract complaints

“Don’t be lazy” is useless.

“Yesterday you recommended terminal A, then terminal B, then terminal A again in the same conversation” is useful.

Agents pattern-match better against concrete reproductions than against moral advice. Frankly, so do humans.

3. Treat the wiki as part of runtime behavior, not just documentation

If your memory system is actually read during future sessions, then it is not only an archive. It is one of the controls that shapes what the agent does next. Design it that way.

That means caring about status, freshness, and whether a note is historical context or current guidance. It also means accepting that some of your best fixes may look embarrassingly low-tech.

And if your stack does not have a CLAUDE.md equivalent, the idea still transfers. Any text that gets re-injected into context at session start is a lever. The filename is incidental.

The part I keep coming back to

What changed my mind wasn’t that the agent had a bad session. Bad sessions happen.

It was that a markdown wiki, sitting quietly next to the code, ended up being the most practical lever for changing the agent’s behavior the next day.

Not memory as autobiography.

Memory as control surface.

And once you see that, a lot of “AI tooling” starts looking strangely overengineered for the problems people actually have. Sometimes the useful move is not another layer of automation. Sometimes it is one sentence in the right file, where the model is forced to read it before it starts improvising.

That’s a very old kind of software.

It still works.

Reference: the Reddit thread “Anthropic made Claude 67% dumber and didn't tell anyone, a developer ran 6,852 sessions to prove it” (r/ClaudeCode, 2026-04-10), and the underlying issue at anthropics/claude-code#42796.