Lawpatch is a collection of open source legal language that makes drafting agreements simple. It can shorten technical legal documents to a quarter of the usual length. It can make make technical legal drafting comprehensible to non-lawyers and it can create language that operates across jurisdictions (think jQuery for law).
The comparison below shows a Lawpatch clause on the left and the legalese equivalent on the right.
|Lawpatch (14 words)||Legalese (76 words)|
|Provider limits liability as much as the law allowsto Customer for the Services.||Client deals with Provider in respect of the Services at its own risk. To the fullest extent permitted by law, Provider excludes all liability (including any kind of consequential or indirect loss like loss of profits, pure economic loss or loss of opportunity) to Client for any liabilities connected directly or indirectly with the dealings of the Client and the Provider in relation to the Services, including liabilities based on contract law, tort law and legislation.|
Legal agreements govern almost everything important… and everyone hates reading them.
It’s clear why: agreements use lengthy, jargon heavy language to describe even the simplest arrangements. Bad drafting is often to blame, but even the best plain-English-drafting lawyer is forced to draft agreements that are partly verbose and obscure.
Centuries of court judgements and legislation endeavouring to govern the world's complexities, edge cases and loophole seekers add up to a complex web of concepts (the law) that an agreement needs to weave into a set of instructions for a relationship (the agreement).
The law is so complex that the simpler a legal agreement is, the fewer relevant details it will cover. With one eye on their insurance policies, lawyers tend to opt for the comparative safety of well-worn but unfriendly legalese.
We (lawyers from the United States, United Kingdom and Australia working on Lawpatch) think there is a way out of the “simple equals risky” conundrum.
“Incorporation by reference” is a simple idea: if you want a contract to include a set of rules that’s written somewhere else, you can make those rules part of the agreement by referring to them. For example, in some employment agreements, a company’s HR policy will be incorporated by reference. Breaking a rule in the HR policy is breaching the contract.
Documents can be identified and included by reference to a title and date or, for our purposes, a URL or defined phrase.
At the end of most legal agreements are a bunch of clauses known as “boilerplate”. Boilerplate clauses cover topics like:
These clauses stay the same for almost every agreement.
To avoid repeating the boilerplate every time, we drafted open source “sensible boilerplate” for the US, UK and Australia, and put it in a version controlled filing system on the Web so that it can be incorporated by reference with a URL - we use Git). Adding the boilerplate to an agreement then becomes as simple as adding this clause:
The parties agree to the sensible boilerplate terms at this URL.
Implementing boilerplate like this saves time, reduces document length and emphasises terms unique to the transaction. When you need to review the language, it's just a click away.
Folding this much information into such a small, accessible space wasn’t practical before hyperlinks made an extra dimension to documents possible.
While we were drafting sensible boilerplate and another “patch” for interpretation, we decided to draft a proof of concept for the technical area of "limitation of liability”. This is the agreement section that effectively governs who can sue who for what.
You can see one of the positions here. The drafting assumes that certain information is in the clause of the agreement (the “Provision”) that incorporates the patch:
To draft a clause with this information and the patch URL is as simple as:
Provider limits liability as much as the law allows to Customer for the Services.
We don’t want people to use Lawpatch to hide adverse clauses. Agreements should be clear. To that end, we propose to add this snippet to agreements using patches.
The parties agree to this document using Lawpatch language. The Lawpatch language referenced by hyperlink is legally effective, but text used in the hyperlink is for convenience only and is not legally effective.
The limitation language above limits all the Provider’s liability to the Client (to the extent that you can lawfully limit liability).
In many cases, you won’t want to limit liability that much. We’ve created a spectrum of limitation positions (read about it here) ordered from least liability to most liability:
Each Lawpatch limitation position has an optional exception parameter. These are known as “carve outs”, and they’re often used to negotiate compromises. Here’s an example of how a carve out would look using Lawpatch positions.
Lawpatch will work where everyone wants a clear agreement. That will tend to be in transactions where the parties have fairly equal bargaining power.
Where there’s less equality in bargaining power (like companies contracting with consumers), few businesses will think it's worth making their agreements easier to understand (though we’d be happy to let everyone know about enlightened companies who want to lead the charge).
It’s time we stop accepting legal agreements where crucial sections are unintelligible to ordinary people. We think Lawpatch is an easy-to-implement, concrete step in the right direction.
If you're interested, do get in touch. We’d love to speak with: