Christopher Alexander’s architectural theory of a "pattern language" influenced the development of object-oriented computer programming. This pattern language framework also explains the design of legal contracts. Moreover, the pattern language rubric explains how legal agreements interlock to create complex transactions and how transactions interconnect to create markets. This pattern language framework helps account for evidence, including from the global financial crisis, of failures in modern contract design.
A pattern represents an encapsulated conceptual solution to a recurring design problem. Patterns save architects and designers from having to reinvent the wheel; they can use solutions that evolved over time to address similar problems. Contract patterns represent encapsulated solutions within a legal agreement (or set of agreements) to a specific legal problem. This problem might consist of a need to match the particular objectives of counterparties in a discrete part of a bargain or to address certain legal rules. A contract pattern interlocks, nests, and works together with other contract patterns to solve more complex problems and create more elaborate bargains. Interlocking patterns enable scalability. If Alexander’s architectural patterns for rooms create patterns for buildings, which create patterns for neighborhoods and cities, then patterns of individual contract provisions form legal agreement patterns. Patterns for legal agreements, in turn, interlock to create patterns for transactions, which mesh to create patterns for markets. For example, contract patterns help lawyers draft real estate contracts. These contracts interlock in sophisticated real estate transactions, which mesh with other contract patterns to form securitization transactions. Securitization patterns create markets for asset-backed securities, which form part of the larger shadow banking system.
This scalability differentiates contract patterns from boilerplate. However, legal scholarship on boilerplate – including Henry Smith’s work on the modularity of contract boilerplate – illuminates how contract patterns function and how they allow certain debt contracts to become what Gary Gorton calls "informationally insensitive" and to enjoy many of the economic features of money.
The pattern language framework explains not only how sophisticated contracts function, but also how they fail. The pattern language framework provides a lens for examining recent contracts law scholarship on the failures of sophisticated contract design, including "sticky" contract provisions in sovereign bond agreements, "Frankenstein" contracts in mortgage-backed securitizations, and the "flash crash." If modularity and contract design patterns foster the development of new financial instruments and markets, then their features can also contribute to the unraveling of these markets. For example, by restricting the information content of contracts, patterns and modularity not only midwifed the creation of liquid markets for those contracts, they also played a role in "shadow bank runs" and the catastrophic freezing of these markets. The failure of contract patterns can have systemic effects for entire markets when a particular contract enjoys widespread use or when it is so connected to other critical contracts that cascading failures occur.
This essay was a contribution to a symposium for Larry Cunningham’s book, Contracts in the Real World
- Financial Markets
Available at: http://works.bepress.com/erik_gerding/10/