Picture a journaling app built for one person. It runs on their own computer, and their phone is paired to it over a secure channel, so they can write at the desk in the evening and read back on the way to work. Each morning the app opens a fresh page, and some mornings it asks about a plan they wrote the day before. Writing in one place and seeing it in the other is the reason the app exists. I call that a journey, the thing a particular person comes to the product to get done, told from their side rather than the code's.

Now hand that codebase to an agent, after months of building it with agents, and ask for one more feature. It will usually deliver. Somewhere in the delivery, a draft written offline comes back twice after a crash, or the morning question quietly stops appearing on the phone. The decisions that should have prevented it were written down somewhere, but no check failed when the change ignored them.

When a change breaks a journey and nothing notices, I call it journey decay, and it compounds because of what the next session does. An agent that runs into a gap its predecessor caused will often treat it as how the product works and file it as a new task. I think it is the maintenance problem that matters most in agent-built software, mostly because nothing fails until the person using it notices.

A loop of five steps: a new feature request, context that holds the new intent but not the old, the agent imitating nearby code, the old journey breaking with no check failing, and the next session reading the broken code as the norm.
One turn of the decay loop.

What the benchmarks measure

Most coding benchmarks hand an agent one isolated task and grade one patch, which says little about living with a codebase. Newer ones keep it moving. SWE-CI replays long stretches of real commit history and asks agents to keep the code working as each change lands. Most models get through fewer than a quarter of those runs without breaking a test that already existed, and for more than half of them it gets worse the longer they work. Those tests were already there, and the agents broke them anyway. A test only protects a journey when a failure stops the merge.

SWE-Milestone strings tasks together on one codebase instead of throwing the repository away after each patch. Models that clear isolated tasks with ease fall to under 40 percent once they have to live with their own earlier work.

Isolated tasks80–100
80 to 100
Codebase keeps moving (highlighted)38
SWE-Milestone, task success in percent. Isolated scores are reported only as above 80, and longer tasks explain part of the gap.

So breaking old behaviour while adding new behaviour is measured. Whether a journey survives is not, because benchmarks count tests and almost nobody tests journeys. Reading one as evidence for the other is my inference, and I think a fair one.

Why more context does not fix it

Most of the effort so far goes into telling the agent more, through bigger rules files and more memory. My problem is less with the amount than with what any selection leaves out.

A study of AGENTS.md files tried both kinds, written by an LLM and written by developers. Neither made a measurable difference to whether the task got done, and the generated ones pushed the cost up by about a fifth.

Rules leak even inside one long session. When a session compacts its history, rules about how to work and what not to do are dropped about six times as often as specs about what to build. "The phone always shows what the computer shows" is that kind of rule.

Tape, a specification from the team behind the bub agent runtime, goes further than bigger files. It keeps an append-only log of facts and assembles a fresh view for each task, with summaries that point back to where they came from. That deals with stale summaries and rules lost in compaction, and it is the shape I would want underneath any long-running agent. It still cannot surface a journey nobody wrote down.

Agents also copy whatever sits nearby. A study of vulnerable repositories put flawed code next to the task, and the agents wrote the same kind of flaw into new code, more so when told to match the existing style. That study is about security bugs. I expect the same habit to carry a bad workaround into the next feature, because the agent learns your project from your project, including the parts that have already gone wrong.

The fix nobody needed

The agent does remember things. Often what it remembers is a rule about products in general, and it applies that rule to yours.

Back to the journaling app. Point an AI security reviewer at it and it does what security reviewers are trained to do. Journal entries are personal, so it treats them as private by default. That sounds right, and the design shifts to match. Journal content never goes to the phone, not even over the secure channel the phone was paired on. Nothing crashes and every test stays green. The next morning the computer asks how yesterday's plan went, and the phone, the device the person actually carries, shows a page with no question on it. It takes a person looking at the phone to notice, and a follow-up issue to put it back.

Nobody in that chain was wrong in general. The reviewer gave sound generic advice, and the agents did what it asked. Neither knew who the app was for, or that the product had already decided the paired phone is part of the person's own space. Generic best practice filled the gap.

The research on AI reviewers fits. When researchers sorted the false alarms of an LLM code reviewer, about six in ten came from it not understanding the surrounding code or the domain. In a benchmark of coding agents, removing the one sentence that said what an agent was allowed to touch took one setup from never stepping outside its task to doing so in about one run in six.

This kind of decay is harder to spot than a regression, because the diff reads like responsible engineering. Catching it takes something that knows the phone is supposed to show the question, either a check that fails when it does not or a reviewer who has been told who the product is for.

Every session is staff turnover

Teams have always had a slower version of this. People leave, and the reasons for old decisions leave with them.

Peter Naur argued that a program really lives in the heads of the people who built it, and the code is a lossy record of that theory. A human team loses some of the theory each time someone leaves, but most of the people stay. An agent session keeps none of it. Every task starts with a new hire who reads a slice of the repository, ships a change and is gone within the hour. I think what used to take years of churn on a large team now happens in weeks, and on projects with one person behind them.

A better model will not fix this on its own. It still cannot know about a journey that nothing in its context or its checks mentions. So I think the promise has to live somewhere that can stop a merge.

Checks that block the merge

Your tests already check that functions return what they should. Almost none check what the person came to do, and nothing stops an agent from merging past the ones that fail. I would add what I call an intent ledger, a small record of what the product promised and to whom, kept in three layers from soft to hard.

A stack of 3 layers, CTX at the bottom to CARDS at the top3 plates stacked from the bottom: CTX, REVIEW, CARDS. CARDS, at the top, is drawn in violet and carries a connected graph. The list that follows describes each layer.CTXREVIEWCARDS
  1. CARDS Journey cards that fail the build, each with a persona, a goal and end-state checks.
  2. REVIEW A fresh-context reviewer reads the diff against the personas and their journeys.
  3. CTX An index from files to the journeys and decisions they serve, shown before an edit.
The intent ledger. Context informs, review can block, cards fail the build.

At the bottom is context, and not one big AGENTS.md loaded into every session. An index maps files to the journeys and decisions they serve, and the agent sees the matching ones, along with the persona and the principles behind them, only when it is about to edit those files. This is where a context architecture like Tape fits. It helps, but any selection misses something, so it cannot be the only layer.

Above it sits a reviewer with fresh context. It reads the diff against the personas and their journeys rather than the coding agent's summary of what it did, and it can block the merge. Told who the journaling app is for, it would have asked whether "private by default" was meant to include the person's own phone.

At the top are journey cards. A card is a short file that states one journey from the persona's side, with a goal and a few checks on the end state and no steps. I call it a card because it should fit on one. For the journaling app, one could look like this.

YAML
persona: one person, writes on the computer, carries a paired phone
goal: see the morning journal question on the phone as well
given: the computer asked about yesterday's plan this morning
expect:
  - the phone's page shows the same question
  - an answer given on either device shows on both

The card says nothing about screens or endpoints, so a redesign passes it and the privacy change fails it at the merge. A second card would say that a draft written offline comes back once after a crash, with the same text. The persona does not have to be a person, either. It can be an operator, or another system calling your API, and the journey is still what it needs to get done.

Most checks like these belong in ordinary fast tests against the API or the stored state. Only the few journeys that cross several screens need an agent to drive them, and those get a step budget, so an agent cannot pass a journey that got worse by clicking through five extra menus. They run nightly or before a release, several times each, so the result is a pass rate rather than a coin flip. StrongDM, which runs what it calls a software factory with agents doing the building, says it keeps some of its test scenarios hidden from the agent that writes the code. By their own account that stops the agent coding narrowly to the tests, and it is worth borrowing. I would hold back a few cards the same way.

Agents may add cards. They may not weaken, skip or re-baseline one without a named human approving it, and an ownership rule on the cards directory enforces that. The same team reports agents writing return true to get a narrow test passing, so I would not leave this to trust.

The same rule separates decay from a deliberate change. Products drop journeys on purpose all the time. With the ledger, dropping one means a person retires its card and writes down why. A journey that disappears without that record was never a decision.

Left alone, a card directory grows into thousands of brittle tests. I would cap it at the 10 to 30 journeys that would actually hurt to lose, assert end states only, and delete any card that goes months without failing and does not catch a deliberately planted bug. The running costs are a reviewer call per change and the nightly agent runs, both small next to the human time spent on the cards each week. That human time costs the most, and it sets how far this can scale.

When nobody is in the loop

All of that leans on a person. Someone owns the cards directory, approves a retired card and reads what the reviewer flagged. Plenty of teams now want that person gone. A dark factory is a pipeline where agents write, review and ship the code and nobody reads it.

Run the journaling app through one. The security reviewer's finding goes straight to a coding agent, which builds it. A week later another agent finds the phone's question screen unreachable, reads it as dead code and deletes it. Each step is reasonable on its own and no check fails, and the person ends up with a phone that shows less than the one they paired.

For greenfield work and short-lived software with strong automated checks, I can see a dark factory working. For software that has to keep its journeys alive for years, I have not seen evidence yet. That same team is the only one I found that has published how it protects old behaviour, and nobody has measured it independently.

A factory writes code well. It cannot write its own oracle, the thing that says what the product is for, and left to own that it drifts toward whatever is easiest to make green.

So the human job in a dark factory is writing the cards and deciding when one may change. It is a smaller job than writing the code, and it is the one that decides whether the product still keeps its promise to the person using it. I do not know yet whether one person can keep up with a factory that erodes journeys as fast as it builds features. I would start with three cards for the three journeys that would hurt most, and add one each time a break shows where the gaps are.

Sources

What this leans on

  1. SWE-CI, for regressions piling up as agents keep a real codebase working across its commit history.
  2. SWE-Milestone, for the drop from isolated tasks to a codebase that keeps moving.
  3. Gloaguen et al., Evaluating AGENTS.md, for context files making no measurable difference to success while adding cost. …
  4. StrongDM, software factory, and Simon Willison's write-up, for hidden test scenarios and agents writing return true.

Disclosure

In case you were wondering

Yes, agents were involved, and given the subject it would be odd if they were not. Research agents found and cross-checked the studies, and a separate pass checked every number against its source. The agent drafted from my notes, and we went back and forth on it a fair few times. The argument, the journaling app and the frustration that started it are mine. If a sentence I meant to keep decayed somewhere between drafts, nobody wrote a card for it.