How to Use AI for Quality Checks Before Delivering Client Work

If you use AI for pre-delivery quality checks, the realistic approach is to split your checklist into items that can be checked mechanically and items that need your own judgment, and give only the first group to AI. Handing over everything blurs who is responsible for what gets missed, and the accuracy of the checks actually drops.

Freelancers who take on writing and document work often keep a pre-delivery checklist in a spreadsheet. Before long it grows past 20 items, and right before a deadline it turns into a good-luck charm: eyes slide down the list without really checking anything. Building AI into the process changes that into a division of labor, where half the list goes to the machine and your attention goes to the other half. This article covers how to split the list and how to run it.

Why checklists turn into good-luck charms

A freelancer's checklist grows by one line after every incident. Deliver with a typo and "read the final draft from start to finish" gets added. Send an old version of a file and "check the date in the file name" gets added. There's almost never a chance to remove anything, so the list only grows. And the longer it gets, the more the checks become a formality for a tired brain near a deadline.

The number of items isn't the only cause. Look closely at what's on the list and most of it is stuff that's obvious once you look, but boring to look for: inconsistent spelling or terminology, numbers in the text that don't match the charts, file naming rules. These checks get skipped precisely because they're boring. Items like "does this match what the client wanted?" aren't boring, but they take real thought, so they also get shallow when you're tired. The real reason checklists stop working is that items of very different kinds are mixed together on one sheet.

Which items go to AI and which stay with you?

One criterion is enough: can the correct answer be written down in a document in advance? Style rules and naming conventions can be documented, so checking against them can go to AI. The intent you picked up from conversations with the client, or the factual accuracy of what you wrote, can't be fully captured in a document, so those stay with you. A typical list sorts out like this:

The "AI and you" rows need a note. AI typo checking is practical, but it never catches everything. The right order is to let AI find candidates first and then do one final read yourself. The reverse order backfires: seeing AI's list of findings makes you feel safe, and your own read gets careless.

Turning the checks into reusable prompts

The key to running this is not writing check instructions from scratch each time, but saving them as templates. After some trial and error, a format like the following tends to work.

First, keep your style rules and delivery requirements in a separate document and hand it over with the draft every time. If the prompt also specifies the output format, such as "list every place that breaks the rules, quoting the relevant line," reviewing the findings goes much faster.

Second, don't pack too many items into one request. Give it 20 items at once and the later ones are usually checked noticeably less carefully. Splitting the checks into two or three items at a time, in separate conversations, works better. It looks like more work, but with saved prompts the only real cost is pasting and waiting. The time from finished draft to delivery stays about the same as doing everything by eye. What changes is that you no longer spend your focus on boring comparisons.

Third, treat AI's findings as candidates. Verifying a flagged spot before fixing it comes naturally. The danger is the other direction: letting an item through unchecked because AI said "no issues found." With factual accuracy especially, AI may write up checks it never actually performed as if they were results, so "no problems" should never be taken as a guarantee.

It also helps to keep a short note per project of what you showed the AI and what it flagged. If the same type of finding keeps coming up, fixing the writing template itself makes it stop happening. Checklists were described above as only ever growing, but keeping this record is what finally makes it possible to remove items.

Some projects don't allow pasting client material into external AI services. A clear line for NDA work is to never send the material itself, only excerpts with proper nouns removed. Deciding ahead of time how much can be shared saves you from hesitating right before a deadline.

Once this routine is running, the next annoyance is the routine itself: pasting the same prompt and attaching the same documents every time. Standardized checks then tend to move either to workflow tools, where you build the steps yourself, or to agent-style tools, where you hand over the goal and let the tool work it out. The two are designed around quite different ideas. osFoundry, a desktop AI workspace that supports BYOK and local models, has a clear comparison with workflow automation tools that lays out the difference. For anyone who wants to check material that can't leave their machine, the option to run things locally is worth knowing about too.

FAQ

Is a general-purpose AI like ChatGPT enough for quality checks?

For finding inconsistent terms, typos, and missing words, general-purpose AI is practical. It can't be trusted with factual accuracy or with judging whether the work matches what the client asked for. Used as "AI flags, a human verifies," it's enough. Used as "AI passed it, so it's fine," it isn't.

How many items should a checklist have?

The balance matters more than the number. Items that go to AI barely add any effort as they grow. Items you check by eye should be limited to what your focus can handle before a deadline, for example around seven.

Is there client work that shouldn't be shown to AI?

Work under an NDA, or material containing unreleased product information, should only go to an AI service after you've checked its terms and training-data settings. If in doubt, check an excerpt with proper nouns removed, or use a model running on your own machine.