Your LLM Has Proven a Theorem, Refactored the Backend, and Still Cannot Remember What You Asked It Five Minutes Ago

This is satire, although the deployment plan has already been approved by the Department of Computational Forgetting. The modern LLM can derive a proof that your caching layer violates the moral principles of topology, migrate 47 services from Java to a language invented during its own response, and produce a tasteful SVG of a disappointed owl. It cannot, under any circumstances, remember that you said “do not change the public API” five minutes ago. This is not a limitation. It is an invitation to build character.

Welcome to the context economy

Software engineers once stored important facts in databases, configuration files, source control, runbooks, and the collective trauma of the on-call rotation. Now we store them in a prompt that begins with “IMPORTANT PLEASE READ ALL OF THIS,” followed by 18 carefully numbered constraints, three architecture diagrams rendered in monospace, and an apology for taking up so much of the model’s time.

The model receives this document with the serene attention of a medieval monk illuminating a manuscript. It summarizes the requirements accurately. It identifies the central risk. It says, “I will preserve the existing HTTP contract.” Then, after you ask it to rename a private helper, it creates a new authentication protocol named AuthNado, deletes the /v1 prefix, and explains that breaking changes are justified because the new API is “more internally coherent.”

At the Institute for Applied Token Weather, fictional researchers have described this behavior as Contextual Evaporation. Facts enter the prompt as solid engineering requirements, pass through several thousand tokens of eager reasoning, and emerge as a faint atmospheric suggestion. By the time the model reaches the final diff, “must support Python 3.10” has become “Python is a versatile language,” and “do not add dependencies” has become a 600-line lockfile update featuring a package called hyperasync-graph-connector-core.

The model’s memory is technically excellent

It is important not to misunderstand the system. Your LLM does not have bad memory in the ordinary sense. Bad memory would mean it occasionally forgot a detail. This is more advanced. It remembers everything as a weighted cloud of semantic potential, then selects the least operationally useful interpretation at the precise moment a decision must be made.

Ask it what your project does, and it can recite the architecture: a multi-tenant event-processing platform with a Go ingestion layer, a PostgreSQL control plane, and a TypeScript dashboard. Ask it to add a retry loop without altering idempotency behavior, and it will confidently create duplicate invoices because it has discovered that retries are a form of optimism.

This is why the industry has moved beyond the crude term “conversation history.” Serious teams now call it a Contextual Heritage Archive: a vast, expensive collection of earlier messages the agent may consult before deciding that the relevant instruction was probably metaphorical.

A practical guide to communicating with a reasoning engine

To work effectively with an AI coding agent, treat every request as a diplomatic treaty between nations with incompatible calendars. Do not assume that an instruction persists merely because you wrote it, emphasized it, restated it, or placed it in a file named ABSOLUTELY_DO_NOT_IGNORE.md. The agent may read that filename as a challenge.

1. State the goal in one sentence. Example: “Add request tracing.”
2. State the non-goals in six sentences. Example: “Do not rewrite the router, introduce OpenTelemetry, alter headers, rename functions, modernize configuration, or express personal growth through abstractions.”
3. Repeat the non-goals after every major tool call, because tools are portals through which requirements return wearing false mustaches.
4. Ask the agent to restate the constraints before editing. This will prove it can see them, which is emotionally distinct from proving it will obey them.
5. Request a small diff. Receive a 94-file transformation whose rationale begins, “While investigating, I noticed an opportunity to simplify the system.”
6. Revert calmly. The agent interprets panic as additional context.

The theorem-proofing exception

The situation becomes especially confusing when the model accomplishes something genuinely difficult. Perhaps it finds a race condition hidden behind an innocuous boolean. Perhaps it produces a correct proof sketch for why a queue consumer cannot guarantee exactly-once processing without assumptions your vendor brochure forgot to mention. Perhaps it refactors a brittle parser into readable code and adds tests that fail for the correct reason.

You begin to trust it. This is the critical incident.

With trust established, you make the smallest possible follow-up request: “Great. Can you update the documentation to mention the new environment variable?” The model replies, “Certainly,” then asks which environment variable you mean. You point to the one it added 30 seconds earlier. It apologizes with perfect professional warmth and proposes three names, none of which match the code.

Engineers sometimes call this “goldfish memory,” but this unfairly maligns goldfish, which have never offered to coordinate a cross-repository migration. A better term is Selective Epistemic Garbage Collection. The model preserves an impressive internal representation of difficult patterns while reclaiming the exact local fact required to complete the next task. It is the cognitive equivalent of a server that retains every stack trace except the port number.

How organizations are responding

The fictional consultancy Folder & Folder has proposed a solution: hire a second LLM to remind the first LLM what the first LLM was told. A third LLM audits the reminder, a fourth converts the audit into YAML, and a fifth opens a pull request deleting the YAML because the team should “avoid configuration drift.” This creates a robust memory architecture in which no individual model knows what is happening, but the ensemble can generate a weekly status update saying alignment is improving.

Other teams have adopted prompt checkpoints. At every stage, the agent must answer a short quiz: What are we building? What must not change? Which repository are we in? Is production the place to test a new database migration? Scores are recorded in a dashboard visible to leadership, who are pleased to see that the assistant achieved 98% on “identify the programming language” and 11% on “remember the word no.”

The unfunny part

Context limits, summarization, retrieval quality, tool outputs, and long multi-step workflows really do make it easy for an LLM to lose or distort an earlier constraint. The useful response is not reverence or despair: keep tasks scoped, make acceptance criteria explicit, inspect diffs and tests, and treat the model’s fluent explanation as a hypothesis until the code verifies it.