A Seven-Point Checklist Before Delivering ChatGPT Output to Clients

Sending an AI-generated draft straight to a client carries a risk that isn't about it producing obvious nonsense—that kind of error is easy to spot. The real danger is when it produces content that "looks completely correct," and that type of error is precisely the hardest to catch. A miscalculated number, an unauthorized promise, or a fabricated rule can all reach the client under your name.

This article compiles an actionable seven-point review workflow that applies to any scenario where you're about to deliver a ChatGPT draft to a client—whether it's an email, a quote, a customer service reply, or a process document.

Why "Looks Right" Is More Dangerous Than "Obviously Wrong"

Large language models have a typical characteristic when handling tabular data: they're strong at locating rows but noticeably unreliable at doing arithmetic. A model can accurately find the corresponding line item in an invoice, yet give a result that's off by a few dollars when summing. This kind of error triggers no error message, the formatting is perfect, the tone is professional, and it's nearly impossible to catch by eye when buried among correct numbers.

Even more insidious are commitment-type statements. When polishing a reply email, the model may naturally slip in a discount, a delivery date, or a line like "we'll be in touch later." To the model, this is just a continuation of linguistic fluency; to you, it's a formal commitment made in your company's name. The same applies to rule-type statements—if the draft says "refunds can be requested at any time," but your actual policy isn't that, the sentence constitutes a potential legal risk.

The instability of large language models at arithmetic has its roots in their underlying mechanism. A model doesn't perform deterministic calculations like a calculator; instead, it predicts the most likely next token word by word based on the massive amount of text it saw during training. Numbers in its representation space are closer to "symbols" than "values," so it's good at recognizing patterns like "this row is the sum result," but it struggles to guarantee the precision of digit-by-digit addition. This is also why the same prompt can yield different totals at different times or with different temperature parameters. By contrast, tasks like locating rows and matching fields rely on semantic similarity, which happens to be the model's strength. Understanding this distinction helps you judge which steps must be manually reviewed: any output involving precise calculations, numerical consistency, or boundary conditions should be treated as a draft that cannot be directly trusted.

The Seven Checks Before Delivery

The following seven checks are arranged in operational order, each corresponding to a category of high-frequency risk.

1. Recalculate Every Total Yourself

Never trust any sum the model provides. Pull out the raw data and add it up again with a calculator or spreadsheet formula. This is the most tedious and least skippable of the seven checks.

2. Read Every Commitment Line by Line

Dates, discounts, follow-up promises, delivery times—confirm that any statement of the form "we will do something" has internal authorization. The model doesn't distinguish between "descriptive language" and "legal commitment."

3. Check the Rules the Model Wrote Itself

If the draft mentions rules such as refund policies, warranty terms, or scope of service, compare each one against the company's actual policy. The model may generate a seemingly reasonable rule based on general business common sense from its training data.

4. Find the Extraneous Content

Watch for things you didn't ask for: add-on services, extra freebies, details of unknown origin. The model often adds these on its own in order to "make the answer more complete."

5. Trace Every Number Back to Its Original Source

Compare every number in the draft against the original table, invoice, or email. Don't compare formatting—compare only the values themselves.

6. A Green Checkmark Only Means the Process Ran, Not That the Result Is Correct

In an automated workflow, a node executing successfully and returning a result doesn't mean that result is right. A pipeline running end-to-end and the result being accurate are two independent things.

In automation tools like n8n or Zapier, a successful node execution status code only reflects that "this call didn't throw an error"—it has nothing to do with the correctness of the business result. The model may return structurally complete JSON with every field populated, yet the sum value within it is wrong, and the workflow still marks it green. Such workflows often write results directly to a database or send them to the client, so errors get silently amplified. A feasible approach is to add a validation step after key nodes—for example, having another model or script independently recompute and check against a threshold, or dropping results into a review queue instead of sending them out directly. Distinguishing "execution succeeded" from "result is trustworthy" is an easily overlooked basic principle when designing AI delivery pipelines.

7. Read Through the Whole Thing Before Delivery

The last line of defense: read it from start to finish as a reader would. Because the final name on it is yours, not the model's.

How to Turn the Seven Checks into a Two-Minute Task

Manually checking each item sounds time-consuming, but there's a simplifying trick: have the model first list out every number, date, and commitment that appears in the draft.

Once you have that list, you only need to run checks 1, 2, and 5 against it. The vague feeling of "something seems off" is transformed into a line-by-line verification of a short list. This typically takes only two minutes.

A real-world case comes from an automated chat workflow built in n8n: it successfully located the correct data row, yet produced an incorrect result at the summing step, and the entire workflow threw no exception. This case shows that even a structured automation pipeline needs human validation at the output stage.

A complete demonstration of this method (including the real-world case) is included in a free course, useful for practitioners who frequently deliver AI-generated content to clients.

The reason "have the model list all numbers, dates, and commitments itself" works is that it turns a verification task from open-ended judgment into closed-book comparison. The model's list itself may also contain omissions, so the list is more like an index than an authoritative source—you still need to treat the raw data as the ground truth and check every line on the list. In practice, you can have the model output in a fixed format, such as a three-column table: type, quoted text, location, which makes for quick scanning. For longer drafts, you can extract in multiple passes by section to avoid omissions caused by excessively long single-context input. After finishing the checklist review, read through the full text once more—combining the two covers the vast majority of high-risk errors.

One-line Summary

A seven-point review workflow for delivering AI drafts to clients, focused on guarding against subtle "looks right" errors.

Paragraph Summary

The article points out that the most dangerous AI-generated content isn't obvious nonsense, but subtle errors with perfect formatting buried among correct information—such as a miscalculated number, an unauthorized promise, or a fabricated rule. These errors trigger no alerts and are hard to catch by eye. To address this, the author compiles a seven-point review workflow: recalculate every total, confirm authorization for every commitment, verify rule and policy statements, remove extraneous content, trace every number back to its original source, distinguish a workflow running end-to-end from a correct result, and read through the whole thing before delivery. The article also offers a simplifying trick—have the model first list all numbers, dates, and commitments in the draft, then verify against that list line by line, turning vague worries into a two-minute actionable check.