A manual validation task that used to cost five person-days a month came down to 1 hour, 26 minutes and 28 seconds. Accuracy landed close to 100%.
Background
Every month, the team receives a batch of product SKUs. The system collects product images within authorized scope for those SKUs (main images and detail shots), runs OCR over the text in those images, then feeds the extracted text to a large language model for analysis, and finally produces an Excel file with the results.
The pipeline sounds smooth enough. The problem sits in the very last step — once the Excel is generated, it still needs manual validation.
The columns most relevant to this optimization:
| Column | Content | Notes |
|---|---|---|
| B | OCR text | Raw recognition results |
| C | Annotation text | Marks inside the image, such as asterisks and superscripts |
| D | Explanation copy | The explanation corresponding to each annotation |
| J | Product SKU | Groups the multiple images of the same product |
Columns C and D are where things break most often. A product usually has multiple images, one row per image. An annotation may appear in the current image, but its explanation doesn’t necessarily live on the same row — sometimes it’s buried in another image of the same product. So validation can’t happen row by row; you have to look at all the image text under one SKU together.
This manual pass used to cost roughly five person-days every month.
What this write-up covers is compressing that work down to 1 hour, 26 minutes and 28 seconds.
The Original Problem
Even with OCR and an LLM in the pipeline, the final output wasn’t stable enough. The errors concentrated in columns C and D:
- Missing C entries — the image clearly contains annotation text, but it was never extracted
- Empty D entries — the annotation was captured, but no matching explanation was found
- Mismatched content — both C and D are filled in, but paired with the wrong counterpart, or non-annotation content got picked up as an annotation
These errors flow straight into downstream usage, so after every run a human still had to go over the file.
Open the Excel row by row, cross-check the image text by SKU, and judge whether C and D are actually correct. Month after month.
Why a Plain Script Won’t Cut It
This looks like a “extract fields from text” problem, and the intuitive answer is a handful of regexes. In practice, though, annotation formats are wildly inconsistent.
Some are common asterisks or numeric superscripts, some are parenthesized notes, some are fine print along the page edge; some explanations sit right next to their annotation, others are scattered at the bottom of the detail page. On top of that, OCR output is noisy — word order, symbols, and line breaks can all shift.
Force a script through this and you run into two walls:
- Rules too strict, and plenty of real cases slip through
- Rules too loose, and promo notes, disclaimers, and ordinary selling points all get misclassified as annotations
NOTEWhat this kind of task actually needs isn’t “more regexes” — it’s a simulation of how a human validator thinks: read all the text under one SKU first, then decide which annotations and explanations are high-confidence, and only touch the parts you’re sure about.
A script can’t do that. A large language model can.
The Approach
Rather than dressing the problem up as another scripting task, this time Codex took over the manual review step.
The Codex Skill here isn’t a one-off chat prompt — it’s a fixed pipeline with fixed rules. Input scope, batching, judgment criteria, output format, and verification are all locked down. Each month, you just hand it the new source file and it replays the same workflow.
The core idea:
Group the Excel content that needs review by SKU, then let Codex analyze each group’s OCR text, existing C/D values, and contextual evidence. For blanks or errors it can judge with high confidence, it produces a change list; anything uncertain stays untouched and gets flagged for human follow-up.
The flow never asks the model to “guess the whole spreadsheet in one shot” — it splits manual validation into controlled batches:
- Each batch handles a set of SKUs
- Each batch reports progress and change counts
- On completion it automatically moves to the next batch
- It only stops when every SKU is done
This keeps the LLM’s strength at reading unstructured text while avoiding the omissions and mid-run drift that come with oversized single tasks.
To make review easy, every modified cell gets a color code:
| Color | Meaning | Example |
|---|---|---|
| 🟡 Yellow | Was empty, now filled in | Column C had no annotation, but clear evidence turned up in another image of the same SKU — filled in and marked yellow |
| 🔴 Red | Had content, judged as a high-confidence error | C extracted the wrong annotation, or D picked up the explanation belonging to a different annotation — corrected and marked red |
TIPThis design matters — it doesn’t disguise the automated output as gospel. Instead, “additions” and “corrections” are clearly separated, so the human reviewer only needs to look at the marked cells and quickly gauge reliability.
Results
After this optimization, the ~five person-days of monthly manual validation came down to 1 hour, 26 minutes and 28 seconds.
154 SKUs were processed in full. 101 SKUs received high-confidence fixes; 53 SKUs were left as-is due to low confidence — nothing was force-edited to look productive.
327 C/D cells were modified in total: 24 yellow fill-ins and 303 red corrections. The final verification passed with ok: true. Human review feedback: accuracy close to 100%.
The cost structure shifted too. It used to burn people’s time; now it burns model tokens — about 3.11M tokens this run, roughly 2.79M input and 317K output. Compared to five person-days of labor, that’s more predictable and keeps amortizing as the monthly workflow repeats.

Full Numbers
| Metric | Value |
|---|---|
| Total SKUs | 154 |
| SKUs reviewed | 154 |
| SKUs pending | 0 |
| SKUs with changes | 101 |
| SKUs skipped (low confidence) | 53 |
| Cells modified | 327 (24 yellow + 303 red) |
| Runtime | 1 hour 26 minutes 28 seconds |
| Token usage | 3.11M (2.79M input + 317K output) |
| Verification | ok: true |
| Human review | Accuracy close to 100% |
Lessons Learned
One thing stood out in this exercise: a single prompt won’t solve a complex spreadsheet task.
Especially with OCR noise, cross-row context, non-standard formats, and business judgment in the mix — dump the whole Excel at a model and ask for results directly, and stability falls apart.
The more dependable path is to design a workflow for the model:
- Define the input scope
- Define the judgment criteria
- Define when a change is allowed
- Define when content must be preserved
- Define the state after each batch
- Define how the final review works
IMPORTANTThe real win isn’t giving the model “more freedom” — it’s making it work inside a process that’s clear, traceable, and reviewable.
Wrap-Up
The core value here is turning a monthly, five-person-day manual chore into a reusable, traceable, reviewable Codex Skill.
It didn’t try to enumerate every annotation format in rule scripts, nor did it let the model bulk-fill the spreadsheet unconstrained. Instead, Codex reviews in SKU batches, edits only with high confidence, leaves uncertainty alone, and color-marks every change.
For tasks in this shape — “too irregular for rules, but with a clear human judgment path” — this approach beats plain scripting and lands much closer to automation that actually survives contact with a real business.
Going forward the numbers can accumulate month over month, both to evaluate the ROI of this setup and to spot which products or scenarios still deserve close human attention.