Substantive Legal Software Quality: Is Your AI Lawyer Actually a Liability?

TL;DR

As automated legal apps (ALATs) move from "experimental novelties" to "critical infrastructure" for self-represented litigants, a quality crisis is brewing. This paper by Lauritsen and Steenhuis warns of a "gathering storm" of mechanical malpractice caused by opaque logic and poor engineering standards. The solution lies in treating legal code with the same rigor as safety-critical software, using formal verification and decoupled architectures.

The Hidden Crisis in LegalTech

We are currently witnessing an explosion of interactive legal tools—from "DoNotPay" chatbots to sophisticated document assemblers like HotDocs. These systems prometheanly offer access to justice for those who can't afford $400/hour attorneys. However, the authors point out a dangerous paradox: Usability is not Correctness.

A legal app can have a beautiful, mobile-responsive UI but contain fundamental logic errors in how it calculates a statute of limitations or determines eligibility for bankruptcy. Because these apps are often built by committees of non-programmers using "low-code" tools, the "phase space" (the total number of possible logic paths) is rarely fully tested.

Why Current Methods Fail (The Motivation)

The paper identifies several "drivers of degradation" in legal software:

• Logic Entanglement: Legal rules are often "hard-coded" into the UI (e.g., hidden inside a 'Next' button), making it impossible for a senior lawyer to review the law without reading computer code.
• The "Amateur" Gap: Lawyers don't know Software Engineering (SE) best practices (like version control or unit testing), and SEs don't understand the nuance of legal "judgment."
• Implicit Implications: Apps don't just provide what they say; they imply permissions. If an app lets a user skip a field, it implicitly says "This isn't required," which might be legally false.

Methodology: Engineering "Ascertainable Correctness"

To move from "prototypes" to "trusted agents," the authors propose a shift toward Visible Reasoning.

1. The MVC for Law

The core insight is to treat legal software through the lens of the Model-View-Controller (MVC) pattern.

• Model: The "Pure Law" (Deontic propositions: obligations, permissions).
• View: The "Interview" (The UI, plain language helps).
• Controller: The "Reasoning Engine" (The logic that connects user facts to legal outcomes).

2. Tools of the Trade

The authors analyze several platforms, highlighting how they handle (or fail to handle) quality:

• Docassemble: Praised for being API-driven and supporting Python, allowing for automated testing.
• Neota Logic: Highlighted for its "Why Ask" and "Static Analysis" features that explain the logic path to the developer.
• A2J Author: Noted for its visual maps, though it struggles with "hidden" logic in complex branching.

Experiments in Verification

The paper suggests that the AI & Law community should contribute "exercise programs"—software designed specifically to interrogate other legal software.

• Formal Verification: Reducing a legal interview to a Finite State Automaton (FSA). If you can map the app as an FSA, you can mathematically prove that there are no "dead ends" or illegal states.
• Regression Testing: Using tools like Selenium or Gherkin scripts to simulate thousands of users to ensure that a fix in "Child Support" logic doesn't accidentally break "Alimony" calculations.

Typical complexity growth in a legal app "Phase Space".

Critical Insight & Conclusion

The authors conclude with a sobering "Standard of Care." For every set of inputs, the system should behave in a way that a human expert would not find objectionable.

The Takeaway: We are entering an era of "Algorithmic Accountability." If a legal app gives bad advice that leads to an eviction or a lost custody battle, "As-Is" disclaimers may not protect providers forever. The "storm" is coming, and our best umbrella is a combination of Formal Logic and Open Engineering Standards.

Future Outlook

The next frontier isn't just "Document Assembly"—it's Agentic AI. As systems begin to file papers directly with courts (e-filing), the cost of a "bug" moves from a typo to a due process violation. The authors call for the AI & Law community to stop focusing solely on academic models and start helping secure the "machinery" of justice.