Case file, automation

The contract generator knew the rule. Nobody had taught it "unless."

A local masonry contractor's agreement tool worked perfectly until a small repair job needed different payment terms.

Try the Unless Map

What kind of job came in?

Normal path, handled automatically

The rule: Part of the money up front, the rest when the work is done.
Who decides: Already decided. The generator drafts it.
What happens next: The draft goes to the contractor for final review.

Known exception, handled automatically

The unless: Unless it's a small repair job. Then nothing is due up front.
Who decides: The owner defined this rule once.
What happens next: The generator drafts with full payment at completion, then the contractor reviews it.

Stop and ask

The unless: The job doesn't match any known pattern.
Who decides: A named person at the business, not the software.
What happens next: Nothing is drafted until that person decides.

The three paths the generator runs now. Examples show the workflow's logic, not the client's actual contract.

Starting problem: One payment rule for every job
Role: Mapped the exceptions, extended the existing generator
What shipped: Three paths: normal, known exception, stop and ask
Verified outcome: Known exceptions apply automatically. Unknowns go to a person.

Write the exceptions down before touching the code.

We had built a standard software contract generator, not an AI tool, for a local masonry contractor. It worked exactly as designed: it produced a clean contract using the payment terms the business uses on almost every job, part of the money up front, the rest when the work is done. Then a small repair job came through. On jobs like that, this contractor does not take anything up front; the full amount is due when the work is finished. The generator was not broken. It simply had never been told that arrangement existed. It knew the rule. Nobody had ever taught it the word "unless."

So the business's actual exceptions were mapped first, using a simple four-column exercise we call an Unless Map: the normal rule, the "unless" that breaks it, who decides, and what happens next.

The Unless Map diagram: a four-column table (normal rule, the unless, who decides, what happens) and a three-path flow showing the normal path and known-exception path handled automatically, and the stop-and-ask path handing off to a named person

Three paths, not smarter software.

The system now runs three paths instead of one: the normal path (handled automatically), the known-exception path (handled automatically once someone has spelled out the rule, like the small-repair-job case above), and a stop-and-ask path for anything that does not match a known pattern, which hands off to a named person instead of guessing. No new AI platform or vendor was introduced.

When it doesn't know, it stops.

The goal was never to make the software exercise judgment it doesn't have. It was to help the system recognize when a person's judgment is needed, and know exactly who to hand that off to.

True now.

The normal path runs automatically.
Known exceptions apply without anyone re-explaining them.
Anything unfamiliar goes to a named person instead of a guess.
The contractor still reviews final terms before anything is sent.

Not measured.

How much rewriting time this saves hasn't been measured. What changed is when problems surface: before an agreement goes out, not after.

Workflow & Process Automation Your Business Runs on the Word "Unless" Next case file: Our own site scored 25 All work

Have something that should be on this page?

Tell us what's broken, slow, or stuck. The first conversation is free.

Start here Contact us Call (423) 967-5584 Text Book 15 minutes