Entropy Debt Week is about what every transition leaves unpaid: the lost distinctions, buried paths, deferred costs, and damaged returns that do not appear in the success report. The debt remains in the field, waiting for someone else to pay it, repair it, inherit it, or mistake it for nothing.
It is very small and technical. It runs from the command line.
It exists because a transition can complete and still bury the path behind it.
And still, some prior distinction may no longer be reachable. Some valid source state may no longer cross. Some reverse path may only pretend to return. Some alternate upgrade route may arrive at a different future. Some pipeline may destroy the relevant difference three steps before the final symptom appears.
Most software tooling is good at asking whether the operation completed.
Backpath asks what the operation closed.
Start with two old states:
and:
Both are valid. They mean different things. One says a person approved the thing. One says the system approved it through an automatic path.
Now migrate them into a simpler target format:
{ "approved": true }
This migration may be intentional. The target may be valid. The product team may have decided that the new system no longer needs to know how approval happened. That can be totally fine.
But the transition has still done something exact:
It took two source-distinct states and made them target-equivalent.
Backpath names that distinction_collision.
It can emit a witness saying:
{
"operation": "distinction_collision",
"status": "witnessed",
"classification": "distinction_collision",
"source": {
"a": { "approval": "manual" },
"b": { "approval": "automatic" },
"differencePaths": ["/approval"]
},
"target": {
"a": { "approved": true },
"b": { "approved": true }
}
}
This is not a sermon against simplification. It is not an automatic bug report.
It is just evidence. The transition made a distinction unrecoverable under the declared contract.
Now, the team can decide whether that closure was acceptable.
Before Backpath, that question often had to be held in someone’s head. After Backpath, it can be placed into a pull request.
Backpath currently names five transition-loss operations.
A valid source state cannot cross.
The old field admits the state. The new transition rejects it, crashes on it, times out, emits malformed output, or produces an invalid target.
valid source
↓
no valid successor
The ordinary system might say, “the migration failed on this input.”
Backpath says, more specifically, “this input was inside the declared source domain and could not cross the transition.”
Two meaningfully different source states become equivalent after transformation.
source A ≠ source B
↓ ↓
target A = target B
This is the approval example. It is also the user-role example, the timezone example, the permission-collapse example, the case-normalization example, and the “missing, null, and empty string all became the same value” example.
The important thing is not that bytes changed. Bytes always change. The important thing is that a distinction the source contract recognized is no longer available in the target field.
A source state crosses forward, then fails to return as an equivalent source state.
source
↓ forward
target
↓ reverse
not the same source
Backpath separates several cases here.
Backpath does not condemn a lossy target when the transition contract explicitly includes retained memory.
A forward transform may emit:
{
"target": { "approved": true },
"memory": { "approvalMode": "automatic" }
}
If the reverse path receives both the target and the memory, then the source may come back honestly:
{ "approval": "automatic" }
Backpath treats that as a valid return contract. The target alone forgot. The transition did not.
Two declared routes from the same source reach non-equivalent terminal states.
route A → terminal A
source
route B → terminal B
This happens when systems have multiple lawful paths forward: direct upgrade versus staged upgrade, branch migration A versus branch migration B, export/import route versus native migration route.
Backpath asks whether those routes arrive at the same future under the declared terminal equivalence contract.
If one route turns:
{ "name": "Mara", "role": null }
into:
{ "name": "Mara", "role": "member" }
and another route turns it into:
{ "name": "Mara" }
the routes disagree. Both may be valid. Both may be supported. Backpath does not need to know which route is right to witness that they do not preserve the same terminal state.
A pipeline may only show damage at the end, but the loss happened earlier.
Backpath can take a distinction-collision witness and replay it through a declared pipeline to find the edge where the distinction first collapsed.
minor ≠ dependent
↓ edge 1
minor ≠ dependent
↓ edge 2
restricted = restricted
The useful sentence is:
The distinction survived edge 1 and collapsed at edge 2.
That is more repairable than “the final migration is lossy.”
This was the surprise. I did not think I would need to make this. Backpath is not made out of alien materials. Its neighbors are everywhere.
Property-based testing can generate examples and shrink failures. Fuzzers can mutate inputs until a program cracks. Schema registries can reject incompatible schema changes. Migration tools can run upgrade and rollback scripts. Contract tests can check whether services still understand each other. Data-quality frameworks can validate expectations. API diff tools can show what changed between specifications. Bidirectional transformation research has studied round trips for a long time.
All of that is close. None of it is quite this. Backpath’s object is not a crash, a broken test, a schema diff, a failed rollback, a contract mismatch, or a data-quality violation.
Backpath’s object is a transition-loss witness: a concrete, replayable example of something the transition made unreachable.
That is the gap.
Backpath does not claim the neighboring tools are wrong. It claims the neighboring tools leave an operation unnamed.
Given a transition, find the smallest concrete witness of what it made unrecoverable.
That sentence should already have had a standard tool. I could not find one, so Modal Path Ethics has built one.
Backpath belongs where old state is being passed into a new field and the success signal is too thin. Here are the obvious first places:
Use Backpath around tools like Flyway, Liquibase, Alembic, Rails migrations, Prisma migrations, or custom migration scripts.
Those tools manage the migration stream. Backpath checks concrete state behavior around the stream.
A database migration can preserve table validity while collapsing a business distinction. For example:
trial_user
paid_user
legacy_paid_user
may all become:
active_user
Maybe that is correct locally. Maybe billing, support, entitlements, audit, and refunds all disagree.
Backpath’s role is not to manage the migration, only to produce the witness that shows what the migration did to reachable state.
Use Backpath when a system has v1 payloads, v2 payloads, compatibility adapters, request normalizers, or response translators.
An OpenAPI diff can show the specification changed. A schema check can show the new payload shape is legal. Backpath can run concrete old payloads through the converter and ask what happened.
A payload with:
{ "delivery": "pickup" }
and one with:
{ "delivery": "curbside" }
may both become:
{ "deliveryMode": "collect" }
That may be intentional. It should not be invisible.
Schema registries are good at compatibility rules. Backpath can sit next to them and test concrete event transformations.
A registry may allow a schema evolution because old and new consumers can still read messages. Backpath asks a different question: when the event is upgraded, normalized, or projected, which distinctions survive?
This is useful for systems where events become audit records, analytics facts, compliance evidence, or user-visible histories. Compatibility is not the same thing as preservation.
Backpath should be used wherever a product claims users can export and later import their data. That includes account exports, workspace exports, save files, project archives, settings backups, CMS exports, notes apps, design tools, and game editors.
The product may produce a valid export file. The import command may run. The rebuilt workspace may open.
Backpath asks: did the return path actually reconstruct the source under the declared equivalence contract?
If tags return in a different order and tag order does not matter, declare that. If internal IDs change and IDs do not matter, declare that. If comment threading, permissions, authorship, timestamps, or folder placement matter, Backpath can make their loss visible.
Games carry strange state. Inventories, flags, quest states, procedural seeds, world edits, relationship values, puzzle states, map discoveries, and one-off event residues all become migration hazards. A save file can load in the new version while silently invalidating a prior route.
Backpath can be pointed at save-state converters. The witness does not need to know the whole game. It only needs valid source states, a transform command, a target schema, and equivalence rules.
For an indie game developer, this is probably one of the first practical use cases.
Configuration files are full of meaningful distinctions that look boring until they break production.
{ "mode": "manual" }
and:
{ "mode": "auto" }
become:
{ "enabled": true }
The service still starts. The config validates.
The old operational distinction is gone.
Backpath is useful before shipping new config formats, especially when old installations are upgraded automatically.
This may be the highest-risk use case.
Permissions and roles often get simplified because the old system has too many weird categories. Some categories are genuinely redundant. Some carry legal, safety, billing, support, or abuse-response meaning.
Backpath can test the proposed simplification before the old categories vanish.
It can say:
guardian and parent became adult
moderator and owner became admin
suspended and deleted became inactive
trial and paid became active
Again: maybe that is the intended transition. Backpath exists so the disappearance has a witness.
Backpath does not replace Great Expectations, dbt tests, warehouse checks, or validation dashboards. Those tools ask whether the data satisfies expectations after the pipeline runs.
Backpath asks whether valid source states lost reachable distinctions while entering that pipeline.
So use both.
The data-quality tool can say:
Backpath can say:
Those are different sentences.
Backpath should be boring in practice.
Put old-state examples in a corpus. Declare the source schema. Declare the target schema. Declare equivalence rules. Point Backpath at the transform command. Run it in CI before migration code lands.
If it finds a witness, attach the witness to the pull request.
That is basically the whole recommended integration.
No ceremony. Just a small instrument that says what the transition made unreachable.
Backpath does not know what matters unless the user tells it.
That is the only honest way to build this tool.
Sometimes these two states are different.
{ "email": "modalpathethics@example.com" }
{ "email": "ModalPathEthics@example.com" }
Sometimes they are really the same.
Sometimes array order matters:
{ "steps": ["verify", "charge", "ship"] }
Sometimes it does not:
{ "tags": ["ethics", "games"] }
Sometimes generatedAt matters. Sometimes it is noise.
Backpath supports exact equivalence and structural equivalence. Structural equivalence can ignore declared paths, compare declared arrays as unordered, and normalize values through simple rules like lowercase, uppercase, trim, and sort-array. This is why the witness is always contract-bound.
Backpath does not ever say:
This transformation is bad.
Just:
Under this source domain, this target domain, and these equivalence rules, this transition produced this witness.
Backpath has four epistemic statuses:
witnessed
proven_within_domain
not_found_within_budget
indeterminate
A concrete witness is decisive under its contract. If Backpath finds two valid source states that become target-equivalent, the collision exists.
A finite exhaustive enumerator can support proof within the declared domain. If the domain has twelve states and Backpath checks all twelve, then the no-witness result can honestly say:
proven_within_domain
A generator cannot do that. A generator can search. It can find witnesses and increase confidence. It can cover many examples. It can be useful in continuous integration.
But if it does not find a witness, it only earns:
not_found_within_budget
The same is true of corpus mutation. A mutated corpus may uncover a failure. A no-witness result is still bounded by the search.
Backpath is deliberately stingy with proof language.
This is one of the places it inherits the temperament of the Klein Conformance Protocol.
The instrument must not launder its own limits.
The Klein Conformance Protocol asks whether a claimed execution has evidence.
It separates intention, plan, trace, signature, bundle, verification, observation, and what remains unproven. That separation matters because a system can claim action without proving that action occurred through resistant matter.
Backpath asks a neighboring question: whether state remained reachable.
Both are evidence disciplines for transitions.
The Transition Action Equation gave Modal Path Ethics a planning-side equation for movement through structured resistance. It reduced a region of the field into a navigable path problem while keeping the reduction visible.
Backpath makes a different cut. It reduces a transformation field into concrete witness operations:
That is why this is not simply a developer tool dumped on a philosophy website.
Modal Path Ethics is a language-game-technology project. The technology side cannot be exhausted by one instrument. Klein was one instance: evidence for action through resistant matter. Backpath is another: evidence for what transitions make unrecoverable.
A moral framework does not become technical by decorating software with moral vocabulary. It becomes technical when it finds an operation that was missing and builds the smallest usable instrument for that operation.
Backpath is that kind of attempt, again.
Backpath is a release candidate.
Modal Path Ethics does not ask systems to preserve every path forever. That would freeze action into archival cowardice. The ethical question is not whether anything closed. Every action closes something. The question is whether the closure is justified by what it makes reachable, what it burdens, what it hides, and what it prevents future agents from repairing.
Backpath lives one layer below that judgment.
Software is full of little afterworlds.
A migrated database. A converted file. A normalized event. A simplified role model. A new API version. A saved game after a patch. An exported workspace after import. A configuration file after upgrade.
Each one carries a story about what still exists. The old state is supposed to be in there somewhere.
Sometimes it is.
Sometimes it has been compressed into a form that can still act, but can no longer remember.
Backpath was built for that moment. It gives the old field one last chance to speak in the new one. Not as nostalgia, obstruction, or a demand that nothing ever change.
As evidence.
A transition that cannot show what it buried is not automatically wrong, but it should not get to call the burial nothing.