Should lawyers learn to code?
Yes, but we should not strive to be coders
Published on: Aug 14, 2016
For the past several years, I’ve been asked one question many times: “should lawyers learn to code?” Over those years, my view has been mostly consistent… “yes, lawyers should learn to code.” Probably unsurprising, given that I wrote Coding for Lawyers several years ago.
But, there’s always been a lingering bit of doubt. “Should all lawyers learn to code?” I would quietly ask myself. “Why?” I’d wonder. What specifically about coding did I think lawyers should learn?
Recently, the parlor game has been played out many times over amongst the #legaltech set, and folks are taking sides. So now, despite my previous reservations, here is my full-throated argument for why lawyers should learn to code.
At the outset, it’s probably the wrong question. As I suggested a few weeks ago: “Asking whether lawyers should learn to code is like asking whether lawyers should read fiction.”1 Reading fiction can help a lawyer improve her legal writing. It can help foster greater empathy and understanding of others’ motivations. Reading fiction can provide balance and joy to a lawyer’s life. No one would scoff and wonder aloud “why would a lawyer waste her time reading fiction instead of the latest article from the Yale Law Journal? Instead, lawyers should make nice with authors and literature critics who do this for a living.” Right? This is a patently absurd argument.
Except the argument reveals the deeper concern: that “learning to code” is actually a shibboleth for “lawyers should be coders.” For my part, I do not think that lawyers should be coders. Lawyers have many duties and obligations, and writing production code should not be one of them. Although there are some remarkable lawyer-coders out there, I have no utopian illusions of – or desire for – armies of lawyers submitting upstream pull requests on open-source law-related software. In that regard, even though I took a course in plasma physics in undergrad, I probably will never make any contributions to the field as a professional plasma physicist. For that matter, even though every lawyer has suffered through attempting to understand the Rule Against Perpetuities, very few of my friends in practice actually need it in daily practice.
In short, if “should lawyers learn to code” is the wrong question, “should lawyers be coders” is a false question. No one seriously asks it. But enough dodging the question.
Should lawyers learn to code? Part of my hesitation in answering the question is that “should” is normative, not objective. As someone who has written code and found it both pleasurable and professionally rewarding, encouraging others to learn to code seems like a no-brainer. But it also implies priorities.
If a lawyer had a choice between reading Python Documentation or representing her client, the answer is pretty clear: “No, coding comes second.” But if there’s a choice between learning about REST APIs and reading a Law Review article in a topic not directly relevant to your practice, how should you decide? For that matter, should lawyers learn French? Should lawyers learn to garden? Should lawyers learn to weld? This sort of analysis eventually reduces to arguments about how you can use coding skills to better serve clients.2 And that, in turn, circles back to whether lawyers should be coders.
This sort of analysis, for what it’s worth, is not limited to law. Some have made the case that everyone must learn to code and others have argued compellingly against it. In some sense, I imagine this debate as not much different from that which took place when deciding whether drivers’ education should be taught in schools (nota bene: that book is fascinating, definitely encourage you to click through).
As such, I will not appeal to the practical benefits of learning to code as something that will improve the practice of law. Instead, I propose that the best reason to learn to code is that it can improve the interaction of lawyers and the non-lawyers.
I have, over the years, watched many lawyers and non-lawyers talk past each other. Many lawyers assume that developers are either code monkeys who should just focus on implementing the latest lawyers’ vision for a better “app” or magicians who can solve any societal ill, usually through hand-wavy big-data “solutions.” Still other lawyers believe that code can never solve any problems because they perceive computers as being unable to solve complicated questions. This is all wrong in my estimation. But, I also understand why lawyers hold these views. Before I started my journey in learning to code, I held many of these same beliefs. Once I started to see things from the perspective of a developer, I gained better insight into how I might frame the questions and challenges.
Similarly, as much as it pains me to admit it, non-lawyers have wildly incorrect views of what practicing law is actually like. It seems so deceptively simple: if only we did “X”, then justice would achieved. Over time, folks who have actually worked in the trenches of legal technology observe that the answers are out there, they are just not easy.
The lack of clear communication is unhealthy for society. Lawyers, much to technologists’ chagrin, can make or break the advance of technology. Given that we are still in a period of relative infancy in grappling with the effect of digital technologies on law and society (let alone the practice of law), lawyers really ought to understand basic concepts like data encryption and even machine learning. On the other end of the spectrum, technology can help us tackle societal challenges; consider body cameras and the effect of DNA technology on criminal justice. Unfortunately, I suspect if you were to ask technologists whether they primarily view lawyers as partners in the march toward a more just society in the digital age, you’d hear a resolutely negative response.
Ultimately, lawyers and non-lawyers must learn to talk to each other. To collaborate with each other. To tackle society’s challenges together. And that requires empathy for each other’s domain expertise.
In that sense, I believe that it is relatively easier for the legal community to take the first step.3 All lawyers are part of the same profession, with a mostly unified approach to credentialing academia and professionals. By contrast, developers and technologists need no formal education and have no central professional organization representing the world of code. As such, in a purely tactical sense, it is easier for lawyers a to gain empathy for the fundamentals of code than it would be for the broader, dispersed community of non-lawyers to gain empathy for the fundamentals of law. In other words, we hold the power to create a more just society, and we should wield that power.
Whether lawyers will choose to learn to code is a different question, and one that will no doubt require substantially more discussion, and action. But if we value the idea that lawyers are supposed to be a force for good in the information age, then we need to stop debating whether lawyers should learn to code or not. We should. The sooner the better.
Some have pointed out that the better analogy might be “should lawyers learn to write fiction.” The answer to that question is facially obvious: there’s not a person on the planet who thinks that a lawyer should not learn to write fiction. The question of whether a lawyer needs to be a professional writer of fiction, well, I’ll leave that to the late-night comics. ↩
For what it’s worth, understanding a little bit of code can make lawyers much better consumers of technology and to allow lawyers to ask the right questions. If nothing else, basic understanding of coding can provide a sanity check on some of the more fantastic claims that lawyers will no doubt encounter in the #legaltech space. ↩
It is necessary here to address the critique by Eddie Hartman, that lawyers equate “learning to code” with “working with coders.” I can only speak from personal experience, but I have found that learning to code actually did allow me to work better with coders. I don’t expect that understanding how to use a
mapfunction will magically enable lawyers to communicate with engineers. But it certainly could help lawyers better understand how an engineer approaches her work, and through that understanding gain greater empathy for the beautiful complexity of production code. And, for what it’s worth, coders don’t get a pass here either; building with is still very much a work in progress… ↩