The accretion attractor names a permanent asymmetry. Adding a thing takes one local proof. Removing a thing takes a global proof — read every consumer, every reference, every dependency. Repeated across cycles, systems accumulate, because the math favors addition.
The math is permanent. One of its two cost components is not.
Removal-cost has two halves. The first is pointing: identifying a candidate for removal. Which file, function, field, doctrine line, internal service, role, or rule is the thing that no longer belongs? The second is verification: proving the candidate is actually safe to delete. Does anything still depend on it? What breaks if it goes?
Both halves used to be expensive, for different reasons. Pointing was expensive because it required a human who held the whole stack in working memory. The auditor with that stack-knowledge (the senior engineer who remembered why a service was added, what it was meant to replace, whether the replacement happened, whether the original still had callers) was the bottleneck on identifying candidates. There were few such humans per system, their time was scarce, their judgment did not transfer to junior staff, and the system grew faster than they could read it.
Verification was expensive because it required either crawling every consumer of the candidate or accepting residual risk that a forgotten consumer would break in production. The cost was bounded by the surface the candidate touched. A widely-used field was more expensive to verify than a narrow one.
Pointing was the operator-bottleneck. Verification was the system-bottleneck. The accretion attractor lived in the sum.
Compute-augmentation collapsed the pointing cost. A working AI system can hold the whole stack in working memory and surface candidates a senior auditor would have surfaced, across the whole codebase or doctrine corpus or service registry at once, in minutes. The auditor role used to be scarce and slow to train, with a five-to-ten-year on-ramp before the engineer could see a stack whole. The work that role produced — forty-seven candidates that look like dead weight, ranked by how unsupported they are — is now producible by a focused user with question-formulation skill and an LLM that holds the corpus.
The claim is about pattern-match pointing, not values-judgment pointing. A candidate ranked "no callers since 2022, no downstream tests, no recent doctrine references" is pattern-pointable. A candidate selected because "we have decided to stop supporting this category" is values-pointing and requires the human to declare the value; compute cannot decide what the team wants to be. The cheapening lands on the first kind. The second kind is the same work it always was.
This is the same cost-curve collapse that made tacit operating models legible from the public trail. The mechanism is shared: AI cross-corpus pattern-recognition at single-reader scale used to be structurally impossible and is now routine. What used to take a senior human a quarter, with no guarantee the work would even start, now takes a focused session with compute. The cheapening is contingent on the AI's candidate-quality being at or above what a senior auditor would produce; in 2026 this is uneven across domains, holding well for well-instrumented codebases and less well for tacit-knowledge-heavy systems with thin documentation. The contingency does not invalidate the structural claim; it names where the claim is empirically furthest along and where it still has to catch up.
The auditor's value does not disappear; it moves up the stack. The senior engineer is no longer the candidate-finder. She is the candidate-reviewer, the one who looks at the forty-seven items the AI surfaced and decides which actually warrant the verification cost. The skill is shifting from reading the whole stack to evaluating dense candidate streams without rubber-stamping. Different work, still senior.
Verification did not get cheap. Proving a candidate is actually safe to delete still requires either crawling every consumer or accepting residual risk that something breaks. AI can speed up the crawl, simulate downstream effects, synthesize impact reports. But the verification cost is bounded by the system's own connectivity, and that bound is structural. A widely-touched candidate is widely-touched, and verifying its removability requires touching what the candidate touches. Compute accelerates the crawl. It does not change the surface size.
The asymmetric cheapening matters because it changes which step is the binding constraint. Pre-compute, both pointing and verification were expensive; you needed a senior auditor and a verification process. Post-compute, pointing is cheap; verification is the only remaining bottleneck. Any team that wants to escape the accretion attractor now faces a single dominant cost, not two, and the single remaining cost is one the team can architect against, by building a verification pipeline that pre-compute systems mostly didn't bother to build because pointing was already gating throughput.
The accretion attractor predicted what would accumulate. It did not predict that one of its two costs would lose an order of magnitude inside a few years. It has.
Cheap pointing without a verification pipeline is dangerous. A team that points at forty-seven candidates and deletes them all without verifying has made the system worse, not better. The accretion-attractor failure mode in the post-compute era is not we couldn't identify dead weight. It is we identified candidates and deleted before verifying. Cheap pointing is not removal-discipline. Removal-discipline is the deletion-deadline mechanism the accretion-attractor piece named, and the deadline only protects the team if the verification work is real, scheduled, and paid for.
The wrong response to cheap pointing is to delete faster. The right response is to invest the freed budget into the verification pipeline that compute did not cheapen, so the candidate stream can flow through to actual removals without breaking the system.
A reader testing whether her own audit pipeline has used the new cheap pointing should ask: at what cadence does the pipeline produce candidate lists, and at what marginal cost per candidate? If candidates are still being surfaced one at a time by a senior auditor reading the system manually, the new cost-curve has not arrived. If the audit produces candidate lists in the dozens or hundreds, and senior judgment is spent evaluating rather than identifying, the cheapening has arrived. The two regimes look qualitatively different. A team in the second one ships audits at frequencies that previously would have required ten times the headcount; a team in the first ships audits at the cadence of senior-engineer attention, which is the cadence audits ran at twenty years ago.
The accretion attractor predicted that systems grow because removal is expensive. The math is still right. One of the two cost components has lost an order of magnitude. A team building deliberately can now point at removals at the rate compute can pattern-match the surface. The verification pipeline is what remains expensive, and what the team has to build, because the prior era never required them to.
The window for the asymmetric cheapening is now. Pointing got cheap. Verification did not. What teams do with the asymmetry over the next decade is the work.