{
  "blyg": "0.3",
  "id": "0pwy1mnsf3x2wz9rby8wz6smjw",
  "kind": "fragment",
  "version": 3,
  "at": "2026-11-15T13:53:25Z",
  "note": "expanded the three fixes: cost-to-adder, reader-ignorability test, and why budgets work",
  "pinned": true,
  "origin": "https://www.msweet.net/notes/",
  "author": {
    "name": "Matthew McDowell-Sweet",
    "url": "https://www.msweet.net/"
  },
  "content_md": "Writing and software share an accumulation problem. Volume should go *down* over time but it reliably goes *up*. The reason: complexity accumulates. Each addition is cheap and local, and its cost is paid later, spread across everyone who has to read around it. This is roughly what [Lehman’s laws of software evolution](https://en.wikipedia.org/wiki/Lehman%27s_laws_of_software_evolution) predict: complexity rises unless work is done to reduce it. [Parkinson’s law](https://en.wikipedia.org/wiki/Parkinson%27s_law) makes a similar point about bureaucracies.\n\nThere are three ways to fight it. One is not adding complexity in the first place, which mostly means making whoever adds something feel the cost that would otherwise land on later readers. Another is to compress what already exists, through abstraction and encapsulation or just good ol’ deletion. The test is whether a reader can now ignore more than before; an abstraction that has to be understood to be used is just more stuff. A third is to set a budget, a fixed page count or line limit in advance, so every addition forces a removal. This one works because it doesn’t rely on anyone’s judgement in the moment: the tradeoff is made once, up front, and then enforced.\n\nNone of these seem worth it in the moment, even though they pay off in the long term. So we get accumulation, until a crisis, or some historical event, comes along and corrects it.",
  "content_html": "<p>Writing and software share an accumulation problem. Volume should go <em>down</em> over time but it reliably goes <em>up</em>. The reason: complexity accumulates. Each addition is cheap and local, and its cost is paid later, spread across everyone who has to read around it. This is roughly what <a href=\"https://en.wikipedia.org/wiki/Lehman%27s_laws_of_software_evolution\">Lehman’s laws of software evolution</a> predict: complexity rises unless work is done to reduce it. <a href=\"https://en.wikipedia.org/wiki/Parkinson%27s_law\">Parkinson’s law</a> makes a similar point about bureaucracies.</p>\n<p>There are three ways to fight it. One is not adding complexity in the first place, which mostly means making whoever adds something feel the cost that would otherwise land on later readers. Another is to compress what already exists, through abstraction and encapsulation or just good ol’ deletion. The test is whether a reader can now ignore more than before; an abstraction that has to be understood to be used is just more stuff. A third is to set a budget, a fixed page count or line limit in advance, so every addition forces a removal. This one works because it doesn’t rely on anyone’s judgement in the moment: the tradeoff is made once, up front, and then enforced.</p>\n<p>None of these seem worth it in the moment, even though they pay off in the long term. So we get accumulation, until a crisis, or some historical event, comes along and corrects it.</p>",
  "content_hash": "sha256:2cb5f135929e8efab93fcfac00aed4485d20439765cca99f1065fd405883508e"
}
