Why ChatGPT forgets your test cases
It never had your suite in the first place
A test suite is a large, structured, evolving artifact: hundreds of cases, a naming grammar, fixtures, tagging conventions, an implicit map of what is covered and what is deliberately not. None of that reaches the model unless you put it in the conversation. What you get instead is a generic best-practice suite — reasonable in isolation, wrong for your repository.
Uploaded files stop existing when the chat ends
Uploading the suite works, for that chat. The content is available while the conversation lives, and then it is not — a new chat starts with no idea the file ever existed, which is the same wall described in why ChatGPT forgets your uploaded files. For a suite that changes weekly, re-uploading is a chore that also silently drifts: you rarely re-upload the current version.
Built-in memory stores preferences, not coverage
ChatGPT's memory is designed to carry things like your role, your tone, your standing instructions. It is genuinely useful — it is not an index of 400 test cases with their tags, owners, and rationale. Asking it to hold your coverage map is asking a feature to do a job it was not built for, and the failure is quiet: the model answers confidently from an outdated impression.
The most valuable QA context is historical
The tests that matter most are the ones written after something broke. Their value lives in provenance: this assertion exists because a partial refund double-credited in production, that retry test exists because the payment gateway silently timed out at 30 seconds. That history sits in incident write-ups, ticket threads, and the memory of whoever was on call — not in the chat you opened this morning. Related failures show up as ChatGPT forgetting project context and as losing the requirements the tests were meant to verify, which ChatGPT forgetting product requirements covers.
What QA teams try
A giant prompt template
The standard workaround: a reusable block with the stack, conventions, user roles, and business rules, pasted at the top of every session. It works, and it costs. You pay for those tokens on every request, the template ages out of sync with the codebase, and nobody updates it after the sprint where the naming rules changed.
Re-uploading the suite every session
More accurate than the template, more tedious, and bounded by what fits and what the model can usefully read. It also produces the wrong incentive: because it is annoying, people upload a subset, and the model reasons about coverage it cannot see.
Custom GPTs or a dedicated project
A real improvement — instructions and reference files in one place, shared with the team. Still a silo you maintain by hand: the files do not update themselves when coverage changes, and nothing there is available to the coding agent writing the implementation or the assistant summarizing the release. Two sources of truth for the same suite is how contradictions start.
Pasting the entire spec
Long context windows make this tempting. But a spec describes intent, not coverage, and it says nothing about which cases already exist. You end up with duplicates that pass review because nobody can hold 400 test names in their head either.
The Fix: Give ChatGPT a Persistent QA Memory
The pattern that ends the repetition is to keep your QA context in a memory layer that lives outside any single chat, and let the model read from it. MemoryLake is built for that: your conventions, coverage map, and incident history stored once, retrievable by whichever assistant or agent is doing the work.
Step 1: Create an API key
Generate a key and make your first request in about 30 seconds.
Step 2: Upload your first memories
Drop in the documents, images, and files that define how your team tests: the naming and tagging conventions, the coverage map, test plans, acceptance criteria, post-mortems for bugs that produced regression tests, and the flaky-test list with its reasons.
Step 3: Connect your AI & agents
Give Claude, Codex, OpenClaw, and your other agents access to that memory via MCP or the API. For ChatGPT, retrieve the relevant memory through the API and feed it into the conversation or into your QA tooling — so the model starts from your actual suite instead of a generic one. The point is that all of them read the same source: the agent writing code and the assistant writing tests stop disagreeing about what exists.
What this changes in practice
Do the arithmetic on your own repetition. If a QA engineer re-briefs the model for five minutes at the start of ten sessions a week, that is nearly an hour weekly per person spent restating things that have not changed. If the standing context block is 2,500 tokens and gets sent 30 times a day across the team, that is 75,000 tokens a day — around 2.2M a month — paying to repeat yourself.
The costs that do not show up on a bill are larger: duplicate cases that inflate suite runtime, coverage gaps nobody notices because the model does not know what is missing, and regression tests quietly re-litigated because their reason was never written down. Memory does not make the model a better test designer. It makes it a test designer that knows your suite.
Best practices for QA memory
Store the shape of the suite, not every assertion
You do not need 400 test bodies in memory. You need the map: modules and their coverage level, naming and tagging grammar, what is intentionally untested, which suites are trusted and which are flaky. That is a page or two, and it is what the model is missing.
Record why each regression test exists
One line per test that came from an incident: the symptom, the root cause, the date. This is the single highest-value thing to store, because it is the knowledge that leaves when a person does, and it is what prevents a "redundant" test from being deleted six months later.
Update memory in the same pull request as the coverage
Memory rots when updating it is a separate ritual. Tie it to the change: when a convention shifts or a suite is retired, the same PR updates the stored fact. Prefer replacing an outdated statement over appending a new one — stale QA context is worse than none, because both the model and the humans trust it. The habit generalizes; it is the same discipline behind not re-explaining context to your AI.
Conclusion
ChatGPT forgets your test cases because it never held them. It has no view of your suite, uploaded files leave with the chat, and built-in memory carries preferences rather than a coverage map. Better prompts do not change that; they just make the re-briefing longer.
Put the suite's shape, your conventions, and your incident history in a memory layer your tools can read, and the model's output changes from plausible to usable — cases in your naming style, aimed at what is actually uncovered, respecting the bugs your team already paid for once. That is worth writing down properly, exactly once.