REACTIVE CONTRACTS

Online contracts assembled from interactive, modular clause components

As a transactional lawyer and software developer for over twenty years, I've developed some strong opinions about how business contracts should be done. This project marks the beginning of my efforts to bring those ideas to a larger audience.
I believe that an important branch in the future of transactional law practice will belong to lawyers who are able to communicate with both machines and people.
FLEXIBLE CONSTRAINTS
Business transactions should be simple and painless. Most people prefer to spend as little time and money as possible getting to a signed contract. But most people also worry that they've missed something important, or that they're getting a bad deal. As a result, they turn the deal over to lawyers and other advisors who earn more if the deal takes longer and is more complicated.
It's my belief that constraints are critical to keeping contract negotations on track. By limiting both sides of a transaction to a range of pre-vetted and reasonable standard positions, we eliminate triggers for discord.
AN EXAMPLE
Below, I've embedded an example of a single Reactive Clause, the building block of a Reactive Contract. For this example, I've deliberately chosen one of the most difficult and contentious parts of a contract.
Please spend a moment with the example below. Play around with the settings on the right side, and notice what happens to the legal text on the left side. When you're ready to move on, I'll explain what's happening behind the scenes in more detail below.
SETTINGS

A limitation of liability clause serves to limit the amount and types of compensation one party can recover from the other party.

Set liability rules for each party separately
Set liability rules based on the kind of damages resulting from a breach
Make it clear that indemnified losses are not subject to any of the liability limits
To improve enforceability of this clause, make it clear that it's bound by applicable laws
CLAUSES THAT REACT
What makes Reactive Contracts different from other attempts at organizing model clauses?
In a nutshell:
  • Each Reactive Clause is a small computer program—a component—that comes bundled with a user interface and all of the logic required to adjust the legal language based on input from a user.
  • A Reactive Clause automatically outputs best-practice legal language (based on my opinions about best practices), and updates in real time as the user changes the available options & settings.
  • Reactive Clauses are designed to be assembled as interactive contract documents that can be fine-tuned to fit the circumstances of a specific deal.
  • A Reactive Clause represents not only a snippet of re-usable contract language, but also every permutation of that language that I consider to be useful in situations most likely to arise.
  • My personal opinions about best practices are evident not only in the legal text of each Reactive Clause, but also in the configuration options that are presented, and in any guidance given to users.
POWERED BY REACT
Reactive Contracts bring the full power of Javascript and the React library to contract drafting and negotiations. Since reactive clauses are just functions, users can fiddle with the input parameters via the UI, and the reactive clause automatically outputs formatted legal language.
Each Reactive Clause can be nested inside other clauses or components. That means settings, such as the currency for money values or defined terms, can be set at the agreement level. Settings managed by the parent component will automatically flow down to all child clauses.
GOALS
My goals for this project are two-fold:
  • First, I want to catalog and document all the best practices that I've developed during my successful career as a practicing lawyer.
  • Second, I want to challenge the conventional notion of contracts as boring, stale documents. I want to bring contracts to life through the power of online media.
ROADMAP
I don't pretend to have all the answers. My collection of Reactive Clauses is just meant to be the starting point for further refinement and incremental improvement.
Once I've completed the initial collection of components for my model clause library, the next steps will be:
  • Establishing a provider component for managing defined terms and other context that impact multiple Reactive Clauses.
  • Compiling playbooks of Reactive Clauses based on other peoples' model clauses, including sources like Common Form.
  • Assembling Reactive Clauses into a small collection of model agreements (i.e., Reactive Contracts), with a focus on the most common kinds of transactions.
  • Allowing others to build and curate their own collections of Reactive Clause and Reactive Contracts.
→ More about me and my background
→ Get in touch sol@zenzen.io
© Copyright 2020 Sol L. Irvine All rights Reserved Worldwide