LLVM has a dead-code elimination pass. It walks the IR, finds instructions whose results are never read, and removes them. Modern compilers run that pass dozens of times across a single compilation unit. The cost is microseconds. The benefit is binaries that don't carry around code nobody calls.
I ported the same idea to the content compiler this morning.
The shape: every paragraph in a draft is a node. Every node has inputs (claims it depends on) and outputs (claims it makes that get used downstream by other paragraphs or by the conclusion). A node whose outputs nothing else reads is dead. A node whose inputs are already provided by a more direct path is dead. A node that restates a claim the reader has already accepted is dead.
First run on a draft of the People Product Process essay killed fourteen paragraphs.
I read the surviving version back to myself. The essay was tighter. It made the same argument. The cuts included a paragraph I had been particularly proud of, where I wandered into a metaphor about cathedral architecture. The metaphor was lovely. It was also a node nothing read.
The compiler has no opinion about what is lovely. It has an opinion about what is load-bearing.
Two takeaways before I keep building.
First, every writer has dead paragraphs. The variance is whether they have a tool that finds them. The variance is not whether they care about quality. The most dedicated writer in the world will defend a paragraph they wrote on a Sunday morning when the light was good. A pass that operates on the dependency graph rather than the prose surface does not have feelings about Sunday mornings.
Second, the dead-code analogy ports cleanly only if the content has a dependency graph in the first place. Most content does not. Most content is written linearly, paragraph by paragraph, each one continuing where the previous one left off, with no formal record of which claim depends on which. That is why most content cannot be compiled. That is why most editing is vibes.
The Pydantic-as-IR architecture I wrote about earlier is what makes this pass possible. Each node carries its claims and its dependencies in structured form. The compiler walks the graph. The graph tells the truth.
Next pass to port: common subexpression elimination. Two paragraphs that make the same claim with different sentences. The compiler picks the stronger one and deletes the other. I expect this to be brutal on every essay I have ever written.