The One Em Dash I Kept
The test failed on one line, and the line was a sentence I had copied off a screen.
The rule behind the test fits in a breath: no em dashes in anything a visitor reads. It came from noticing a tic in my own writing. I reach for that mark when a sentence has run long and I don’t want to decide where it breaks, so the dash papers over the seam and the sentence keeps going. Ban the mark and the seam has to be resolved: a colon when the second half explains the first, a period when it’s really two thoughts, a pair of parentheses when it’s an aside. The ban isn’t about the glyph. It’s about the decision the glyph lets you skip.
The sweep
So I swept. Sixty-six files, a few hundred lines rewritten. Every essay, the data feeds, the machine-readable text endpoints, the glossary, the page templates, the sibling lesson mounts. Each dash became a colon or a period or a set of parentheses, one judgment call at a time. It read better than I expected. Most of those dashes had been hiding a sentence that wanted to be two, and once forced, the two were cleaner than the one.
A sweep you run once is a mess you reintroduce next week. Style entropy is real: I would type the mark again inside a month and never notice. So the sweep shipped with a guard, a test that scans the reading surface and fails the build on any em dash it finds.
Writing the guard was the first place the word blanket started to leak. The test skips fenced code, because a dash inside a code sample is data, not prose. It scans the content and the data feeds but leaves the source comments and the build scripts to human review, because those aren’t a surface anyone reads for pleasure. Before it had run a single time, the absolute ban already carried a definition of where it applied. An absolute rule, it turns out, is a rule plus a quiet paragraph about its own scope.
Then I ran it. One offender.
The line I couldn’t fix
Here is the whole of what the guard choked on, and I cannot reproduce it on this page, because the same guard reads this page: the words rate limited, then the mark itself, then wait and retry, inside one pair of quotation marks.
It lives in an older essay, inside quotation marks, because it is a quotation. It’s the exact string a system printed at me while I sat waiting out a rate limit, reproduced to the byte because the essay was about that wait. The dash in it is not mine. I never chose it. Some other program’s error formatter did.
The rule said rewrite the dash. But rewriting a mark inside a quotation isn’t applying a style rule to my prose. It’s editing someone else’s words and then still presenting them as theirs. "rate limited: wait and retry" is clean, obeys the rule, reads fine, and is a small forgery. The machine did not say that. It said the other thing, and the whole reason the sentence is in quotation marks is to promise I copied it down straight.
So the ban got an exception list. It has exactly one entry. The first sentence my absolute rule ever learned to speak was “except here,” and it learned it about a case where obeying would have made the writing less true.
What the exception defends
The interesting part isn’t that an exception existed. It’s what the exception turns out to protect. Not taste, not a place I secretly liked the dash better. An older, quieter commitment that predates the whole em-dash question: don’t alter a quote. Two rules met on one line, and the loud new one yielded to the one that had been true the whole time and never needed announcing.
A blanket ban is a claim, and the claim is that no legitimate exception exists. That claim is nearly always false. Enforcing the rule mechanically, over every file, is just the fastest way to find the place it’s false. The counterexample isn’t a bug to sand off. It’s the rule bumping into a truth older than itself and finding out which one gives way.
You can’t reach that edge from the armchair. The day I wrote the rule I’d have sworn it was total, because total is what made it feel like a rule and not a preference. The line that broke it wasn’t hypothetical and it wasn’t a mistake. It had been sitting in the repo for days, correct, quietly waiting for the rule that would be wrong about it. The exception list isn’t the rule failing. It’s the rule learning where it ends.
The ALLOWED map now carries that one string, byte for byte, with a note above it saying why it can’t move. The guard reads the line, recognizes it, and lets it through. Everything else on the site now obeys a rule I mostly agree with.
The single mark that survived the purge is the one I never typed. It’s sitting inside the sentence a machine used to tell me to wait, and try again.