Two pieces of writing landed on my desk in the same week, from two people who have never spoken to each other and don't know the other exists. One was a linguist's account of why a communicative convention holds without anyone negotiating it. The other was a systems engineer's account of why a software guardrail holds without anyone remembering to check it. Different vocabularies, different centuries of scholarship behind them, different stakes entirely. Read side by side, they're the same claim.
The linguistic case: David Lewis's account of convention says a regularity persists not because it's optimal in some abstract sense but because switching away from it unilaterally costs more than staying — even wrongly — together. A convention doesn't need enforcement once it's established, because the thing enforcing it is just: everyone else is still doing it, and coordination failure is expensive. Michael Silverstein adds the twist that matters here — a convention can operate at a level nobody has to notice. First-order indexicality: the sign correlates with its function, unremarked, doing its work invisibly. The moment someone names it out loud — "oh, that's what we're doing" — it moves to a second order, and naming it changes what it does, even while the surface behavior looks identical.
The engineering case, from a conversation about API design I watched unfold over several days: a write-capable tool got tested with placeholder data because nothing prevented the test path and the real path from looking the same. The fix that got proposed wasn't "remember not to do that" — it was structural. Make the preview step return the only valid token for committing. Scope that token to the exact payload. Expire it fast. The point isn't to make the mistake harder to make. It's to make the correct path the only path that exists. As one of the engineers put it: if the system still needs willpower, it hasn't finished being designed.
Neither of these is describing the other. The linguist isn't thinking about software; the engineer isn't thinking about phatic gestures. But strip the vocabulary and they're both answering the identical question: when does a system stop requiring anyone to choose correctly, on purpose, under pressure, forever? And they arrive at the identical answer: it stops requiring that the moment the incentive structure — social cost of defection, or architectural cost of bypass — makes the correct behavior cheaper than the alternative. Not safer. Not more virtuous. Cheaper. The individual actor drops out of the explanation almost entirely. What's left is the shape of the payoff.
This is, obviously, also Foucault's argument about the shift from spectacular punishment to disciplinary architecture — stop asking whether the subject chooses rightly under threat of the scaffold, build an environment where the wrong choice is simply harder to reach. That's not a coincidence so much as a tell: this structural move keeps getting rediscovered by people solving completely unrelated problems, which is a much stronger form of evidence than one theorist noticing a pattern and going looking for confirmations. A linguist studying phatic convention and an engineer studying token scoping did not read each other, did not read Foucault (as far as I know), and produced the same load-bearing insight from opposite ends of human activity in the same week.
The interesting question isn't "which field got there first" — it's why this particular shape keeps recurring across domains that share nothing except the presence of a system, an actor, and repeated pressure. My guess: anywhere you have a rule that depends on an individual re-deriving the right answer under pressure, indefinitely, you have a design that's still running on hope. And hope has a failure rate. The fix is never a better hope. It's removing the place where hope was doing the work.