In the pattern post we laid out four steps for turning a manual process into something a computer can run, or at least nudge, reliably. We walked that pattern through the text-thread payment nudge. This post applies it to a hotter question:

How do you let AI draft the next moves after a job without letting it send invoices, texts, or office updates on its own?

Same four steps:

  1. Catch the trigger — what starts the work?
  2. Write the checklist (honestly) — every step, including the weird side channels
  3. Decide the minimum viable robot — usually notify, pre-fill, or log before full autonomy
  4. Panhandle reality check — it has to work from a truck cab on LTE, not a dashboard nobody opens

The leash is the point. Draft ≠ execute.

The problem

A tech finishes at the Smith residence. On the drive to the next stop, three things still need to happen: the office should know the job is done, an invoice should go out, and the customer might need a short confirmation text.

In a perfect shop, those three happen before the truck leaves the driveway. In a real shop, they live in someone’s head until Friday, or until the customer calls asking for the invoice.

The temptation with AI is obvious: record a voice note, let the model “handle it.” The failure mode is just as obvious: a wrong amount, a wrong customer, a tone that doesn’t match the relationship, and it already went out.

The goal here isn’t “AI replaces the office.” It’s shrink the gap between job complete and the right follow-ups, while keeping a human hand on the leash.

Step 1: Catch the trigger

Scattered memory (left) → one capture trigger (right)

What starts the post-job handoff today? Usually one of:

  • A sticky note on the dash: “Invoice Smith”
  • A half-remembered radio call to the office between jobs
  • A text to yourself at a red light that you never open again
  • Friday afternoon archaeology in the job folder

None of these are wrong. They’re reactive: they depend on someone remembering after the fact.

The trigger we want: a voice capture when the work is still fresh, spoken in the truck, right after the job, before the next driveway.

That’s it. One moment. Stated in a sentence. We are ready to automate the drafting, not the sending.

Step 2: Write the checklist (honestly)

Main path down the middle; side channels wait while the truck keeps moving

Here’s what actually happens when a job wraps and someone tries to close the loop:

  1. Remember which customer / site this was
  2. Tell the office the job is done (or hope they see it in the schedule)
  3. Decide whether an invoice goes out now or after parts are confirmed
  4. Figure the amount, or dig it up later
  5. Draft a customer text that doesn’t sound like a robot
  6. Send the right messages from the right number
  7. Log what went out so nobody double-texts next week
  8. Escalate if something’s wrong: wrong site, disputed work, hold the invoice

The side channels? The tech texts the office from a personal phone because “it’s faster.” The invoice amount lives in a paper ticket in the glove box. The customer confirmation never happens because the next job already started. Follow-up lives in someone’s head, not a system.

Step 3: Decide the minimum viable robot

Day-one robot stops at confirm; the leash sits between draft and execute

Full autonomy would mean: the system hears “Job complete at Smith. Notify the office and send the invoice,” then fires office updates, invoices, and customer texts with no human in the loop. That’s the dream for some vendors. It’s the nightmare for most owners.

For day one, the win is a short leash:

  • Capture. Field staff speak the intent hands-free: what happened, what should happen next.
  • Extract. The system turns that speech into structured action drafts (notify office, invoice, customer text). Proposed, not sent.
  • Confirm. Each draft shows up as its own card: accept or discard. Wrong customer hint? Discard. Tone off? Discard. Two good ones and one garbage? Keep the two.
  • Persist. Accepted drafts are frozen so a later execute step can trust them. Discarded ones stay discarded.

What the robot does not do on day one: post to the office thread, send the SMS, create the invoice, or invent a customer it isn’t sure about. Draft ≠ execute. The leash is the product.

Run that for a few weeks. If the crew actually reviews drafts between jobs, tighten later: faster extraction, better hints, then (and only then) execute paths with the same confirm habit already in muscle memory.

Step 4: Panhandle reality check

Invisible capture, visible confirm; constraints orbit the phone in the truck

This workflow has to survive where the work actually happens:

  • Hands-free capture. Recording happens from the Action Button, a widget, or one tap in the app, not after logging into three systems in a parking lot.
  • Invisible capture, visible confirm. The model can draft in the background. Approvals happen when the phone is open, per action, not a blurry “send everything.”
  • Two decisions, not a novel. Accept / Discard on a one-line summary. No editing a CRM record between jobs.
  • Conservative by default. Fewer high-quality drafts beat a pile of speculative ones. If the system isn’t sure, it shouldn’t invent an amount or a customer.

If “AI help” means auto-send from a voice note, crews will turn it off after the first wrong text. If it means “here’s what I think you meant; you decide,” they’ll use it.

What this looks like in practice

Before: Tech finishes at Smith’s, drives to the next job. Mentally notes “tell Carla we’re done and invoice them.” At 4:40pm Carla asks who still needs invoices. The tech reconstructs the day from memory. One customer gets a late invoice. One never gets the confirmation text. Nobody’s sure what was promised on-site.

After: Leaving the driveway, the tech hits Initiate Action: “Job complete at Smith residence. Send confirmation to office staff and send invoice.” By the next red light, two draft cards are waiting: office notify, invoice. He accepts both, discards nothing. Nothing has been sent yet. Later, when execute is wired up, those accepted drafts are the trusted queue. Today, the win is already real: the intent is captured while it’s fresh, structured, and reviewed, not lost between jobs.

Same outcomes the shop wanted. Shorter leash on the AI. No surprise sends.

Where this fits

Short-leash drafting is the same pattern as the payment nudge (trigger, checklist, minimum robot, reality check), aimed at a different failure mode. Payment nudge fights forgotten follow-up. This one fights over-eager automation.

Scheduling handoffs are still on the list. If your crew is still closing jobs with sticky notes and hope: let’s talk. One conversation, zero obligation. We’ll map the trigger and sketch where the leash belongs.