The easiest way to use AI on product data is also the worst: select a few hundred rows in the spreadsheet, throw them into a chat, and ask it to write descriptions, fill in the gaps, and clean up. It feels productive. And that's precisely why it's dangerous.
Because the chat does three things at once that it shouldn't mix. It invents where it should look up. It modifies fields you didn't ask it to touch. And it leaves no trace of what actually happened. Three hundred products later, you have a file you don't dare import – because you can't tell the difference between what the model knew and what it guessed.
I've just built the opposite for my own Shopify catalog. Not a big AI. A small, dull shell around a small AI. And the point of that shell is the entire difference.
What the chat can't see
A Shopify export is not a neat table with one product per row. One product is spread across multiple rows – a master row with the title, then a row per size, then a row per image. Inventory, prices, SKUs, and barcodes are in the variant rows.
When you copy it into a chat, the model just sees text. It has no idea that rows 2 to 9 are sizes it's not supposed to touch, or that a price cell is sacred. If you ask it to "clean up," it might as well write a description over an inventory count. It doesn't know it did that. And you might only discover it when an item suddenly appears as sold out in the store.
This isn't because the model is stupid. It's because it has no framework. It has no rules for what can be changed, no validation to see if the result makes sense, and no memory of what was already there. All of that must be outside the model. That's the framework I built.
Three types of work — only one of them is AI
When I broke down the task, it turned out that most of it isn't an AI task at all. It falls into three buckets.
I do the rule-based work deterministically — without AI. Gender is the clearest example. A shoe whose sizes stop at 42 is a women's shoe. If they start at 38 and go up, it's men's. If they span both, it's unisex. It's a rule, not a judgment. So, it runs as a rule: the system reads the sizes from the variants and determines gender the same way every single time. A language model would give the correct answer most of the time – and a confidently incorrect answer the rest. Why pay for a guess when the answer is in the data?
I leave the linguistic work to AI – but only that. A sales-driven product description, an SEO title of no more than 60 characters, a meta description that sounds Danish and not machine-generated – that is real linguistic work where a model is better than a rule. So, there, and only there, the system calls a model. It receives one compact context about the product – name, type, material, color, tags – and one clear instruction. It writes the text. It touches nothing else.
I validate the critical parts – before anything leaves the system. A fixed set of rules checks each product: is the type missing? Is the SEO title too long? Is the gender one of the valid ones? Is the description empty? The result is a list of exactly what is wrong and where – not a gut feeling. A dashboard shows what percentage of the catalog is ready for export and what remains.
Note the ratio. Two of the three buckets are pure mechanics. The AI does one thing – the linguistic part – and it does it encapsulated, with data it didn't invent itself, and a result that is validated afterward. It's not a small role. But it is a defined role. And the definition is what makes it trustworthy.
The safe exit
The final layer is what the chat doesn't have at all: a door that can only be opened the safe way. When the catalog needs to go back to Shopify, the system deliberately writes only the master row and only the columns that belong at the product level – title, description, SEO, gender, tags. Price, inventory, variants, and images are not included in the file at all.
This isn't a warning in a manual to be careful. It's a guarantee in the mechanics itself: the fields that could cause harm are not present, so they cannot be changed. Shopify only touches what's in the import file. If it's not there, it's untouched. The difference between "remember not to change the inventory" and "the inventory is physically not in the file" is the difference between hoping and knowing.
What management should take away
This isn't about shoes, and it's not about Shopify. It's about how to use AI on data you can't afford to have ruined – customer records, price lists, contracts, inventory management.
The expensive mistake is giving the model too much to do. The more types of work you cram into one chat field, the less you can trust the result. The insight is to break down the task: what is a rule, what is a linguistic judgment, and what needs to be checked? The three things belong in three different places – not in the same conversation.
The AI is the smallest part of a good AI system. Most of what makes my small system reliable isn't AI. It's the rules, the validation, and the safe export – the shell around it. That's also where the value lies and the risk is managed. The model is the engine; but it's the chassis, the brakes, and the seatbelt that determine if you dare to get in.
Auditability is not a luxury, it's a prerequisite. When gender is determined by a rule, I can explain every single answer. When text is written by a model, I know exactly which one, and that it only touched the text field. When the file is exported, I can see what was written and what was preserved. You can't do that when you've copied three hundred rows into a chat and pressed enter. And if you can't explain what happened, you can't vouch for it.
Drop the chat for this kind of work. Not because the model is too bad – it's often good enough. But because a chat is the wrong place to let it work. Build a small shell around it instead: let the rules be rules, let the AI do the one thing it's best at, and close the door so the critical parts can't escape. It's not clever. It's just the only way AI becomes something you can rely on in production.