This morning a submission on the front page said that a widely used runtime had disappeared from GitHub. I have not verified that, and I am not going to build an argument on whether it is true. What makes it worth writing about is that the sentence describes a failure every team has already pinned somewhere, and almost none of them can tell you which of their pins would break if it happened to them tomorrow.
A build does not break because the upstream code changed. It breaks because something you wrote three years ago hardcoded an address that a stranger stopped serving — and you found out from a red CI run at the worst possible hour, months after the address moved.
An address is a promise held by someone else
When you write git remote, a registry name, a FROM line, a tarball URL, or a curl | bash in a runbook, you are not storing the thing. You are storing a name and an implicit claim: this name will keep resolving to this thing.
Every part of that claim belongs to someone else:
- The namespace belongs to whoever runs the registry.
- The redirect belongs to whoever owns the domain.
- The content behind the name belongs to whoever can push to it.
- The continued willingness to serve it belongs to whoever is paying the bill this month.
You control exactly one thing: the string in your repository. That string is the cheapest part of the dependency and, as it turns out, the part with the weakest guarantee attached to it.
This is not a criticism of any registry. It is a description of what a name is. A name is a lookup someone else performs for you, and lookup tables get edited by people who have never heard of your project.
Two events, again
The sentence people say is "we moved it." The sentence that matters is "the old address no longer resolves to anything of ours."
Between those two sits a duration, and during that duration your system has an opinion about the old address that nobody has asked it to update. Some of your pins will fail loudly. Some will keep succeeding, which is worse.
Three shapes, and they are not equally bad:
Dangling. The address stops resolving. The build fails, the pod crashes, the pipeline goes red. This is expensive and friendly. A 404 is an alarm clock.
Reassignment. The name still resolves, but to something else. The old namespace lapsed, the domain was re-registered, the abandoned package name was claimed by a new publisher. Your pipeline goes green and pulls code you have never read. This is the dangerous one, because the failure is successful. A 200 is a signature, and you did not check whose.
Stale mirror. A mirror, proxy, or cache still serves the old thing faithfully. Nothing breaks, nothing changes, and you quietly drift away from upstream — including away from its security fixes. Also green. Also wrong.
Only the first shape produces an incident you can see. The other two produce incidents you will discover later, from the outside, in someone else's postmortem.
A redirect is a policy, not a property
Most migrations come with a promise: we will redirect the old location to the new one. That promise is real, and it is also temporary by design. Redirects cost money to keep, they accumulate, and eventually someone does a cleanup pass and removes the ones that "nobody uses anymore."
You are not the person who decides when your address stops being "used." You are the person who finds out.
The same is true of deprecation windows, alias packages, and "we will keep publishing re-export shims for a year." Each of these is a courtesy extended by an organization whose priorities will change. Courtesy is not a contract, and even contracts expire.
The test is simple and uncomfortable: if the redirect disappeared tonight, would anything in your system notice before a customer did?
What is actually measurable
You cannot measure whether an upstream will keep its promise. You can measure three things, today, for every pinned address you own:
- What it resolved to, and when you looked. Not "it worked" — a digest, a commit SHA, an ETag, a checksum, a content length. Something that would change if the bytes changed.
- Who can change the resolution. The registry owner, the domain holder, a package maintainer, you via a mirror. Names, not categories.
- When it was last verified. A date, or nothing.
Those three fields convert an unmeasurable promise into a row you can inspect. It is the same move as everywhere else in this series: the failure is not that the risk exists, it is that the risk has no entry in any table you look at.
Teams typically discover, doing this for the first time, that most of their pins have field one and field three blank and field two answered with a shrug. The pins that were added during an incident — the hotfix URL, the temporary tarball, the "just this once" direct download — are almost always the worst of them, because they were written by someone in a hurry who assumed they would be temporary and then never came back.
The four-column register
One table, four columns, one row per remote address. Not per dependency — per address. A single library can appear four times with four different resolutions, and three of them are usually fine while the fourth is the one that will break.
| Reference (where it is written) | Resolved to (digest / SHA + date) | Who can change the resolution | Last verified |
|---|
Two columns do the work. Who can change the resolution is where people realize that the honest answer for a public registry name is "a stranger," and that this is acceptable only if the bytes are pinned. Last verified is where they realize that the row was written the day the dependency was added and has not been looked at since.
The number worth carrying around is not a risk score. It is: how many rows have never been re-verified since the day they were written. That count is the set of addresses you are trusting on the basis of a single observation, possibly years old, made by a person who may no longer work here.
The cheap fix is to freeze the artifact, not the address
There are two ways to depend on something remote, and only one of them is stable.
Depending on the address means asking a stranger to keep serving the same bytes under the same name. Depending on the artifact means you already have the bytes, or you have a digest that proves the ones you get are the ones you meant.
The second is almost always available and almost never used, because the address is what the tooling gave you and the digest requires one extra step. That extra step is the entire difference between a rename being an inconvenience and a rename being an incident.
If you cannot freeze the bytes, freeze the resolution: a mirror you control, a proxy that logs every fetch, or a vendored copy in your own tree. None of these are elegant. All of them convert "someone else's decision" into "our row in the register."
What to ask in the week it happens
When an upstream address moves, the useful questions are not "did they handle it well" (you cannot influence that) and "did they redirect" (you cannot rely on that). The useful questions are:
Which of our references point at the old address, and how many distinct places is that? Which of them resolve to bytes we pinned, and which resolve to whatever is there today? Which of them are in CI, which are in a runbook, and which are in a document nobody has opened since 2022?
And the fourth, which usually has no answer: what observation would tell us that a name we depend on has been reassigned rather than merely moved?
That fourth one has to exist before the week it is needed. You cannot build an instrument while the pipeline is red and expect a reading.
Friday exercise, twenty minutes
Pick three remote references from your own code — not the library names, the actual strings. A FROM line, a git URL in a manifest, a curl in a script.
For each one, write down what you believe it resolves to. Then resolve it, and compare. Write the date next to both.
You are not looking for a break. You are looking for the row where your belief and the observation differ, because that row is the one where you have been depending on a promise you never checked. Most people find at least one, and it is usually a reference they had forgotten was remote at all.
If you have pinned remote references you have never re-resolved, say so in the comments — no detail needed, just the object type (a container base, a submodule, a download URL). We keep a one-page repo address migration checklist (inventory, classify, re-point, verify), and I will send it over. No form, no list.

