Finish the Text Before It Forks

July 2026

The rule: every editing pass — grammar, style, fact-checking, tone — happens on the source of truth, before the text is copied anywhere else. Once a copy exists on a second platform, that copy is finished. You publish it. You don’t improve it there.

Why

The moment the same piece exists in two places and you edit the second one, you have two partly-correct versions and no authoritative one. Merging them is not a merge. It’s a judgment call on every difference, made by someone who has to remember which change was an improvement and which was a mistake.

It gets worse when the two copies drift in opposite directions — which is what happened to us, and is easy to walk into rather than rare. One copy gets your wording improvements. The other gets a factual correction you found later. Now “use the newer file” is actively wrong — it would push a known error back over a known fix.

Two step-chains compared. The upper one, edit after the copy, runs source, copy made, both edited, two partly-right versions, reconcile by hand, with the last three outlined as cost. The lower one, edit before the copy, runs source, all editing, copy made, one source of truth

The lower path isn’t more disciplined. It just never creates the work the upper one has to clean up.

What it cost us

On 2026-07-31 we published a monthly report to this site, then uploaded the same text to X as a draft, and the editing happened in X’s editor: a grammar-checker pass and a set of hand edits. Folding those improvements back onto the site took a full sentence-by-sentence comparison of the two published copies.

That comparison was worth doing — it caught three genuine problems, including a retracted income figure and a date we’d already proven wrong on the site. But every one of those problems only needed catching because the copy forked before it was finished. The reconciliation pass was not a safety net we designed. It was cleanup for a decision we didn’t realize we’d made.

How to apply it

Do the grammar and style pass on the original file, not on the platform’s copy. If your grammar tool isn’t native to your editor, that’s an argument for pasting into the tool and back into the original — not for editing on the far side of the fork.
Treat “upload” as the last step, not the middle one. If you find yourself uploading a draft in order to read it properly, that’s a signal the original needs a better preview, not that the platform should become your editor.
If a platform genuinely has no update API, this rule gets stricter, not looser. There, the copy you publish is permanent until you’re physically back at a desk — so it had better be the finished one.
When a fork is truly unavoidable, write the comparison as a script before you need it. A diff you run is a mechanism. A diff you remember to do is a good intention.

The general form

One artifact, one source of truth, one place where editing happens. Every additional editing surface multiplies the work by more than one, because the cost isn’t writing the changes — it’s deciding, later, which version was right.

Try this now

Open the last thing you published to two places. Diff the two copies — by eye is fine for one check. If they differ at all, you already have a fork; decide right now which one is the source of truth, and write that down somewhere the next person to edit it will see.

This entry came out of The Bottleneck Is Also the Inspector. Its companion is Treat a Graphical-Only Surface as Terminal — the two are strongest together, and If a Fork Is Unavoidable, Automate the Diff is what to do when this rule can’t be followed.

If this helps you, check out my adblob to support the work.