Turning human judgment into system memory
What building Vernacy taught me about the one part of AI software that AI can't design.
AI can now build a working feature faster than a team can agree on what the feature should do. I've seen that firsthand building Vernacy, the document intelligence platform I'm working on through Melitrus. It turns messy documents, starting with mortgage files, into decision-ready data. AI helped me build a lot of it quickly. It couldn't tell me what Vernacy should do when a document is ambiguous.
Someone still has to define correct
Real documents are messy. Two dates that should match don't. An amendment changes a figure from the original. A value the next step depends on simply isn't there. A coding agent can build an extraction pipeline in an afternoon, but it can't decide which answer is right, or whether the system should answer at all.
That decision is a business judgment, not a technical one, and faster implementation makes it more expensive to get wrong. A team can now build a lot of software on top of an assumption nobody resolved.
How Vernacy handles it
Vernacy doesn't guess. Every document is scored and given a confidence level, and every answer shows its source. Anything below the threshold goes to a person for approval. The reviewer decides, logs the reason, and that resolution becomes part of the system's persistent memory. The next time Vernacy runs into the same kind of ambiguity, it knows how it was handled and why.
That loop is the part of the design I care about most, and AI didn't come up with it. It came from deciding up front that the system should never be quietly wrong, and that every human decision should make it better for the next document.
Judgment that compounds
Most review processes throw judgment away. Someone resolves a hard case, approves it, and the reasoning disappears into an inbox or an approval log nobody reads. The next person facing the same case starts from zero.
Capturing the reason along with the decision changes that. Each resolved ambiguity makes the system a little smarter, and over time the hard cases get rarer because the system has already learned from them. People spend their time on genuinely new problems instead of the same ones again.
What this means for technology leaders
As writing software gets cheaper, the scarce work moves to the edges of the code: deciding what correct means, and making sure human judgment is captured instead of lost.
That applies well beyond documents. Every organization has people resolving ambiguity all day, in underwriting, claims, support, and operations. Most of that judgment evaporates. The organizations that design systems to keep it will get better every time someone makes a hard call. I think that's one of the most valuable things technology leaders can build in the AI era.