The Epistemic Bottleneck: Why AI Gives Engineers 10X and Lawyers 3X

A consensus is quietly forming among lawyers who have seriously adopted AI, not the ones writing thought leadership about it, but the ones actually running agentic workflows on real matters. The productivity gain is real. It is somewhere around 3X. And it is stubbornly refusing to become the 10X that software engineering is currently experiencing.

The comparison is worth taking seriously because the same underlying models produce both numbers. An engineer and a lawyer using the same frontier model, with comparable skill in prompting and workflow design, land an order of magnitude apart. Take both figures as archetypes rather than precise measurements; the argument that follows requires only the gap between them, not the exact values. Whatever explains that gap, it is not model capability.

Most engineers running serious agentic setups no longer read their code line by line. They run long autonomous loops with fleets of agents, review at the level of behavior and architecture, and let the harness catch what they don't see. Meanwhile, a lawyer using AI at the highest level of sophistication still reads every line of advice that goes out under their name.

The interesting question is why, and the standard answers are wrong in an instructive way.

The standard explanations, and why they are secondary

The explanation you hear most often is accountability. It is the lawyer's name on the advice. When things go wrong, the client calls a person, not a chatbot. Bar rules impose supervision duties on work product. Malpractice insurance prices the risk. Courts have made examples of lawyers who filed AI-fabricated citations, starting with Mata v. Avianca in 2023 and continuing through a body of sanction decisions now large enough that public databases track it.Sources: Mata v. Avianca (S.D.N.Y. 2023) · AI Hallucination Cases database

All of this is true. None of it is the binding constraint.

Here is the test: if accountability were the fundamental limit, we would expect the gap to close as professional norms adapt, as insurers develop AI-specific products, as courts and regulators build frameworks for delegated review. Give it five years of institutional adjustment and the 3X becomes 8X.

That is not what will happen, because accountability is the legal system's response to a deeper property of the work, not the property itself. Engineers are also accountable for what they ship. Aviation software, medical devices, and payment infrastructure carry liability at least as severe as a misdrafted contract. Yet verification in those domains still runs at machine speed. The difference is not the stakes. It is the cost structure of checking.

The verification asymmetry

Software engineering earned its 10X through a fact so basic it is easy to miss: the artifact executes. Ground truth for a piece of code is the machine itself. A compiler rejects type errors in milliseconds. A test suite encodes the behavioral specification and runs it on every commit. Static analyzers, fuzzers, and property-based tests probe the space of inputs no human would think to try. Fifty years of sustained investment have driven the cost of verifying code toward zero, and crucially, made it cheaper than generating code.

This is why the agentic loop closes in engineering. The agent writes code, runs the verifier, reads the failure, and revises, thousands of times, unattended. The reward signal is machine-checkable. The agent can run its own examiner.

Now look at what verifying a single legal claim requires. Take a sentence as ordinary as "under Spanish law, the limitation period for this contractual claim is five years." To sign off on that sentence, a reviewer must establish five independent properties:

Existence: the cited source (Article 1964.2 of the Código Civil, in this case) actually exists.

Fidelity: it says what is claimed, at the level of the specific passage, not at the level of general topic.

Currency: it is still good law. Not repealed, not amended since the version the model saw, not superseded by special legislation, not reinterpreted by controlling jurisprudence. This particular article was amended in 2015, which is exactly the kind of fact a model trained on decades of legal text gets silently wrong.Sources: Ley 42/2015 (BOE)

Authority: the source is binding in this jurisdiction, at this level of the hierarchy, for this kind of question. A ruling from an Audiencia Provincial is not the Tribunal Supremo. A panel decision is not en banc. Ratio is not obiter.

Applicability: it governs these facts, this contract type, this temporal regime under the transitional provisions.

Each of these is a lookup against ground truth. But unlike in engineering, the ground truth is not an executable artifact. It is a distributed corpus spread across hundreds of official gazettes, court registries, and consolidated codes, in dozens of languages, versioned over time, scoped by jurisdiction, and mostly not machine-checkable. So the lookup runs through the only verification instrument available: a licensed human, reading at human speed.

That human is the serial fraction of the pipeline. And serial fractions have a mathematics.

Amdahl's law for legal work

In parallel computing, Amdahl's law bounds the speedup of any system by the portion of it you cannot accelerate. If a fraction p of the work is accelerated by factor s, total speedup is 1 / ((1 − p) + p/s).

Apply it to a legal matter. Suppose 70 percent of task time is generative: gathering research, drafting, summarizing, formatting, first-pass analysis. Suppose AI accelerates that portion not 10X but infinitely, to zero time. The overall speedup is 1 / 0.3, or about 3.3X.

The observed 3X ceiling is not a cultural artifact. It is Amdahl's law with verification as the serial fraction.

The arithmetic also tells you what it would take to reach 10X: the unaccelerated remainder must shrink below 10 percent of original task time. If verification is 30 percent of the job today, it must compress by a factor of three or more, in absolute terms, while everything else is automated. No improvement on the generation side, however dramatic, moves this number. You can make drafting instant. The ceiling stays at 3.3X.

This is the part of the debate that model releases keep obscuring. Every capability jump compresses the 70 percent further, produces a wave of announcements, and leaves the 30 percent untouched. The bottleneck is not where the investment is going.

Why better models don't move the ceiling

Four structural reasons, each independent of model quality.

First, calibration does not transfer. A model's fluency is uncorrelated with the legal correctness of its claims. Hallucinated citations are format-perfect, which is precisely what makes them dangerous. A more capable model produces fewer errors, but the reviewing lawyer cannot see which claims are the errors, so the review effort per claim is unchanged. You do not review less because the error rate dropped from 4 percent to 1 percent. You review everything, because 1 percent of a hundred claims is still a sanctionable filing.

Second, the error distribution defeats sampling. Spot-checking works when errors are randomly distributed. Model errors are not random. They cluster exactly in the plausible-looking places: the citation that fits the argument perfectly, the quotation that says what the passage should have said, the precedent that would exist in a well-ordered legal system but does not exist in this one. Checking 10 percent of claims that are adversarially shaped to look correct catches roughly nothing. Review must be exhaustive, which is the expensive kind.

Third, staleness is structural, not incidental. A training cutoff guarantees the model cannot know last month's overruling or last week's amendment. Scale does not fix recency; a model with ten times the parameters is exactly as ignorant of yesterday. Retrieval-augmented generation moves the problem rather than solving it: correctness now depends on the completeness and currency of the retrieval corpus and on retrieval actually surfacing the controlling material, and those are precisely the properties that nobody is verifying.

Fourth, the loss function is asymmetric and lands on a named human. When a coding agent's error costs the engineer a failed deploy and thirty minutes, tolerance for unverified output is rational. When the error is a fabricated precedent in a court filing, the downside is sanctions, professional discipline, and a decision with the lawyer's name in it, published and permanent. Under asymmetric loss, exhaustive review is not conservatism. It is the correct policy.

The omission problem

There is a failure mode worse than fabrication, and it gets a fraction of the attention: omission.

A fabricated citation is at least checkable. It sits on the page, it makes a claim, and a diligent reviewer can run it down. An omitted controlling authority leaves no trace on the page at all. The output is fluent, cited, internally coherent, and wrong, because the case that decides the matter against your position simply never surfaced.

Verifying absence is categorically harder than verifying presence. Confirming that no controlling authority contradicts the analysis requires exhaustive search over a complete, current, jurisdiction-scoped corpus. No human reviewer actually does this. Experienced lawyers mitigate with pattern recognition and citators, but the mitigation is probabilistic, and it degrades exactly when matters cross into unfamiliar jurisdictions or fast-moving areas of law.

This is worth stating carefully, because it inverts the usual framing. Exhaustivity is the one thing machines do better than experts, if and only if the corpus and retrieval layer are engineered for it. Recall in a legal retrieval system is not an information-retrieval metric to be traded off against latency. It is a safety property. A system that can demonstrate exhaustive coverage of controlling authority does something no human review can do, rather than approximating what human review already does.

Errors compound silently

The bottleneck gets worse as legal work looks further forward. Risk assessments, deal structures, regulatory strategy: this is reasoning built on top of backward-looking premises about what the law currently is.

The epistemic status of a conclusion is bounded by its weakest premise. One corrupted input, a hallucinated precedent, a repealed provision treated as current, an omitted line of contrary authority, silently corrupts every judgment built on top of it. And the corruption is invisible in the output, because each downstream inference is locally reasonable. By the time the reasoning is three steps past the bad premise, no amount of reading the final memo will surface the defect. The error does not announce itself. It compounds.

This is why "human review of AI output" is a weaker safeguard than it sounds. The human reviews the conclusion, and the conclusion looks fine. The defect lives in the provenance, and provenance is exactly what current AI output does not carry.

What compressing verification actually requires

If the ceiling is set by verification cost, then the engineering program is explicit: make each of the five checks machine-executable. Concretely, that means infrastructure most of the legal AI industry has not started building.

Resolvable identifiers. Every legal claim in generated output should carry a machine-resolvable pointer to a canonical source, using the identifier systems that already exist: ECLI for European case law, ELI for legislation, Akoma Ntoso as the document model. Existence checking becomes a deterministic resolution, not a human search.Sources: ECLI (Council conclusions, 2011) · ELI (EUR-Lex) · Akoma Ntoso

Span-level grounding. Fidelity should be verified against the literal passage, not the general document. A claim maps to a source span; the span either contains support for the claim or it does not. Semantic similarity is not support. A passage can be squarely on topic and contradict the claim, and embedding distance will not tell you which.

Temporal validity graphs. Legislation should be represented as a versioned graph: amendment chains, derogations, entry into force, transitional regimes. Case law needs citator edges: followed, distinguished, limited, overruled. Then currency checking becomes graph traversal, a millisecond operation, instead of a research task. This is the machine-native version of what Shepard's and KeyCite have done for over a century in a handful of jurisdictions, generalized to all of them.

Authority ranking as data. The hierarchy of sources, constitutional norm over statute over regulation, and the court hierarchy of each jurisdiction, encoded so that a system can rank two conflicting authorities instead of presenting both with equal confidence.

Entailment with a rejection zone. Natural language inference models can judge whether a passage supports a claim, with calibrated confidence. The design point that matters is the gray zone: claims where entailment is genuinely uncertain get routed to the human. The lawyer stops reviewing 100 percent of claims and starts adjudicating the 10 to 20 percent that are actually contestable. That is what compressing the serial fraction looks like in practice.

Verification of absence. Exhaustive retrieval over demonstrably complete corpora, with contradicting authority surfaced proactively rather than on request. Coverage becomes a measured, auditable property of the system.

None of this is speculative computer science. Every component exists. What does not exist, in most of the market, is the willingness to spend on it, because none of it demos as well as a fluent draft.

The compiler law never built

Step back far enough and the 10X in engineering has a simple explanation: it is the return on fifty years of investment in verification infrastructure. Compilers, type systems, test harnesses, continuous integration, static analysis. Generation got fast because checking got cheap first. The agentic revolution in software did not create that foundation. It cashed it in.

Legal AI has made the opposite bet. Nearly the entire investment wave has gone into generation: drafting fluency, summarization, conversational interfaces over documents. Generation was already the cheap part. The result is exactly what Amdahl's law predicts: spectacular acceleration of the 70 percent, an untouched 30 percent, and an industry-wide plateau at 3X that gets rediscovered in every serious adoption report.

The 3X lawyer is real, and worth being. But 3X is a ceiling, not a waypoint. More fluent generation asymptotes toward it and stops. The 10X lawyer becomes possible only when verification runs at machine speed, existence, fidelity, currency, authority, and applicability checked deterministically, with human judgment reserved for the questions that genuinely require it.

Every field that industrialized went through the same migration: the constraint moved from making things to checking things, and the firms that won the next era were the ones that industrialized the checking. Law is next. The order of magnitude belongs to whoever compresses verification.