This problem of a body of written work that grows and grows and becomes complicated and error-prone is daily life to a software engineer. We've developed ways to deal with the problem, under the broad terms "factoring" for code and "normalization" for data. Both refer to an iterative process of identifying redundancy, consolidating the redundant stuff, and reducing a system's overall complexity. Code used over and over goes into libraries. Duplicate data is merged or packed into more efficient structures. There's a strong theoretical basis powering this: Information theory provides many tools to measure your system's redundancy and complexity.

I know you're taking a roundabout path to argue for the same old thing, smaller government, but the problem you give that's symptomatic of bigger government isn't so intractable that you have to resort to strangling the patient in the bathtub. Attack the problem, not your favorite target.

Run the present US legal code through lexical analyzers that match redundant laws and can consolidate them. The law is supposed to be as unambiguous and prescriptive as software, and the inevitable snarls and misunderstandings found in realworld human-written text that make the system ask for human help are a perfect opportunity to examine problem areas and paradoxes in the law.

People have proposed blue-ribbon commisions to do this sort of thing before. Consolidating the tangled legal code isn't a new idea, but it founders on the rocks of politics. We can all see that the power to edit the law is the power to introduce editorial bias, so who do we trust? But I would argue that modern silicon running state-of-the-art pattern recognition can do much of the job objectively and without controversy. The residual controversy will keep legal scholars employed for years, so it's a win-win all around.

Does the solution work? Like I said, we code monkeys have been doing this for a long time. Yeah, it'll work.