A single line in a CLAUDE.md file charged a thousand customers for orders we never shipped. The line wasn’t even wrong.
More than a thousand orders came through our ecommerce stores over about two weeks. The customers were charged. The orders were never shipped. Nothing in our system reported an error at any point, because in a narrow sense nothing had gone wrong — every component did exactly what it had been told to do.
A payment integration is a loop. Your site hands off the payment, the gateway charges the card, and then the gateway comes back to tell your application it worked. Break the first half and nobody can check out and you know within minutes. Break the second half and money moves while your system quietly forgets why.
The break was in a text file.
Our teams keep a CLAUDE.md in the repo — the instruction file the assistant reads at the start of every session. Claude Code reads CLAUDE.md, Codex reads AGENTS.md, Cursor reads .cursorrules, and if you’ve adopted any of them you have one. It’s quietly become the most widely used memory pattern in AI-assisted development, and the formats are converging toward something like a shared standard.
Ours said we integrated with Authorize.net using SIM, the Server Integration Method.
Some context before the obvious question. These stores run on a legacy platform we inherited and support while we migrate them onto our current stack. Deprecated-but-working integrations are the texture of that kind of work — you keep payments flowing until the replacement is ready, and you accept a list of things you’ll fix in the right order. SIM being in production wasn’t the mistake.
The mistake was what our instruction file said about it. Authorize.net deprecated SIM years ago. Their own documentation lists it among the legacy methods being phased out, and the official SIM developer guide is a PDF stamped on its first page with a notice that the API it describes is deprecated. Under SIM, the leg that reports back to your application was called Relay Response — deprecated alongside it, in favour of webhooks.
So we were charging cards through a retired method and depending for fulfilment on a retired response mechanism. It was findable in ninety seconds. Nobody looked, because the file said what we used.
We asked the assistant. That was the problem.
Here’s the part I’ve been chewing on for weeks.
When the client escalations started, the team put the assistant on it. Read the integration, trace the transaction flow, find where the response handling breaks. Sensible. It’s good at that.
It found nothing. Repeatedly.
Not because it wasn’t capable. Because we had told it, in a file it re-read at the start of every session, that we used SIM. So every pass confirmed our SIM implementation was a correct SIM implementation, which it was. Whether SIM should have been there at all was the one question the file had taken off the table.
That distinction is the whole thing. A stale memory that gives you a wrong answer is annoying. A stale memory sitting upstream of the diagnosis is a different animal — it doesn’t hand you a bad answer, it makes the right answer unreachable. And it feels like progress the entire time, because each pass eliminates one more possibility while quietly reconfirming the premise nobody questioned.
We found it by opening a browser and searching the web like it was 2011.
It stated a fact and left out its status
My first instinct was to file this as decay: the file used to be accurate, the world moved, we didn’t keep up. Clean story, and slightly flattering.
But the line was never actually wrong, and that’s the uncomfortable part. It said we integrated using SIM. We did. What it never said was and that method is retired, and this platform is on its way out. It carried the fact and dropped the fact’s status — and an instruction file has no grammar for the difference. It can’t say “this is how it works for now, under protest, until we finish the migration.” Everything in it arrives with the same flat confidence.
Someone wrote it in a hurry, to save the next person some time, describing the system as it stood. Then it became ground truth by the only mechanism these files have: nobody objected. Nothing is so permanent as a temporary note.
So the assistant wasn’t misinformed. It was under-informed, in a way it had no means of detecting. An engineer reading “we use SIM” might have paused and asked whether we still should. The file handed over the same sentence with none of the hesitation.
Our application code has tests. It has reviewers. It gets touched, questioned, refactored, blamed. Whatever strain that review layer is under, at least it exists. A CLAUDE.md gets written once, usually by whoever set the project up, and then it’s read thousands of times and reviewed zero times. It sits in version control, so it looks governed. It went through a pull request once. But nobody re-reads a markdown file looking for lies.
And unlike a retrieval system, there’s no path by which it could ever correct itself. If your knowledge base goes stale you re-index it — there’s a source to check against, a fetch, a way for the world to update what the model sees. An instruction file is asserted, not retrieved. Authorize.net’s deprecation happened entirely outside our stack. There is no version of our setup in which that news arrives.
Which gets harder from here
In the taxonomy the field has borrowed from cognitive science, a CLAUDE.md is procedural memory — and procedural is the type nobody is governing. It’s also the crude version. The layer being built to replace it writes itself: facts extracted from conversations and consolidated across sessions, without anyone deciding to record them.
Which is close to the inverse of the problem I wrote about a few weeks ago, where too much context made agents slower and less reliable. Here the context was tiny. It was just wrong, and it was load-bearing.
Our failure was at least legible. One line, in a file, that a human could open and eventually disbelieve. That’s how we fixed it. I’m a lot less sure what the same mistake looks like when nobody typed it and nobody can read the whole of it.
What we actually changed
Less than I’d like to be telling you.
We moved those integrations onto Authorize.net’s current API — already on the migration roadmap, just not near the top of it — and we updated the CLAUDE.md files. That’s the whole remediation.
I’d rather say that plainly than write a tidier ending. We fixed the instance. What we did not fix, and what I still haven’t fixed, is whatever let a wrong line sit in a file that long, unreviewed, read thousands of times by a tool that treats it as fact.
I think I know what the answer looks like: instruction files reviewed on a cadence, the way you’d audit dependencies, and any claim about an outside vendor carrying a note on where it came from and when someone last checked it. It isn’t complicated. But the last time we met a problem like this with a sensible process, we wrote a six-item checklist, everyone agreed to it in the meeting, and it quietly stopped being mentioned after about three weeks. So I’m not going to announce a practice we haven’t run. Ask me in six months.
The harder one is detection. We had two weeks of money arriving while fulfilment stalled, and nothing was watching the relationship between those two states. I don’t have a general answer there, because the general problem is an uncomfortable one: how do you monitor a system for doing exactly what it was told, when what it was told is wrong?
Our tools are getting remarkably good at reasoning. Nothing is getting any better at doubting us.
So take the small version of this. Go open the instruction file for whichever AI tool your team actually uses, and read it as though a stranger wrote it — which, if it’s been there more than a few months, is roughly true.
And if you support anything legacy, start there. Those are the files most likely to describe a system as it stood three years and two owners ago, because the people who understood it best have already moved on — and because a note written under time pressure about a platform you’re leaving is exactly the kind of note nobody circles back to.
You’re looking for sentences that were true once.
Sources & notes
- Authorize.net Support Center, “Authorize.net Integration Methods Explained” — lists SIM, along with Relay Response and several other legacy methods, as obsolete and in the process of being phased out.
- Authorize.net Developer Center, FAQs — describes Relay Response as the method for transferring transaction results back to the merchant’s site so it can act on them, and confirms it was deprecated alongside SIM in favour of Webhooks. A note on precision: status varies method by method, and several legacy methods remain functional with end-of-life dates still undetermined. “Deprecated” and “decommissioned” are not interchangeable, and a fair amount of secondary commentary online treats them as though they were.
- Authorize.net, Server Integration Method (SIM) Developer Guide (PDF) — carries a deprecation notice for the document and the API it describes on its opening page.
- Instructure/Canvas product blog, March 2023 — a third-party platform notifying customers that Authorize.net had publicly deprecated SIM and recommending migration. Included here as one marker of how long that status had been public.
- On instruction files as a memory pattern — the observation that a markdown file in the project root has become the dominant memory mechanism in AI-assisted development, and that
CLAUDE.md,AGENTS.mdand.cursorrulesare converging toward a shared format, comes from independent analysis of agent memory architectures rather than from vendor documentation or peer-reviewed work. Treat the convergence claim as a reasonable read of the current direction, not a settled fact. - On the four-part memory taxonomy — working, episodic, semantic and procedural memory derive from the CoALA framework and appear in some form across IBM, MongoDB, LangChain, Letta and Mem0 documentation. The automatic-extraction and cross-session consolidation behaviour described in this piece is drawn from the documentation of Mem0, Zep and Letta as of mid-2026; capabilities in this space change quickly.
