- Setting up new products used to take most of a day, sometimes more depending on how many came in at once.
- Claude handles the repetitive parts well: titles, tags, collections, menus, in the right order.
- It can’t figure out your rules on its own. You have to encode them first.
- You don’t need years of systems in place to start. One rule, one product type, is enough.
- What you get on the other side is an operator who never forgets what you told it.
Setting up a new product used to be an all-day job, sometimes longer depending on how many new SKUs came in at once. Optimize the title, map to the right tags and product type, create the collection if it doesn’t exist, wire it into the right menus, check that every attribute follows the vendor’s conventions. With ten new products from two different vendors, that work spills into the next morning and products sit unpublished while the backlog grows.
I run stores with very different catalogs: dog goods and accessories, and pop culture merchandise. They’re all mine, run at different times, and each has its own vendors, naming conventions, and rules for nearly everything. The catalog work that used to pile up is now something I hand off to Claude and review rather than build from scratch. But it took more setup than I expected, and it’s worth being honest about what that setup actually involves.
What made it possible was Claude Code and the ability to build a custom MCP (Model Context Protocol) server: a direct connection between Claude and the store’s Admin API. I built mine before Shopify launched their official connector, and it has capabilities that connector doesn’t: full catalog scanning without hitting token limits, tag dependency checking across smart collections before any changes are made, theme file searching to catch hardcoded references, metafield and metaobject read/write, sales data access, and a built-in dry-run mode so nothing gets committed without explicit approval. Other AI tools I tried couldn’t parse large product exports accurately or connect to Shopify at all. Everything was copy-paste, which defeats the point when you’re trying to operate at scale.
What Claude actually handles in my Shopify store
Product onboarding is the clearest win. New product comes in, I run it through the workflow: title gets structured correctly, tags get mapped to the standardized set, product type gets assigned, collection gets created or the product gets added to the right existing one, menu placement gets handled. What used to eat most of a day now takes a fraction of it, and the product goes live without sitting in a queue.
Order operations is the other area. I built an internal platform to track orders across one of my stores, and getting Claude to read order status correctly required getting specific about definitions. What does “fulfilled” mean in this store’s workflow? What counts as pending? Those aren’t obvious answers, and Claude can’t infer them from context. Once they’re defined and documented, it handles them correctly every time.
Catalog audits are where it genuinely surprises me. Spotting inconsistencies across a large catalog: products where the title doesn’t follow the right structure, tags that don’t match the standardized set, attributes that conflict. That’s tedious work I used to do manually in batches. Claude can scan the whole catalog and surface the issues faster than I can scroll through a spreadsheet.
RelatedYour Shopify Catalog Is the Foundation Everything Else Runs OnYour Shopify catalog is the data layer that search, collections, promotions, and every app in your stack runs on. When it's inconsistent, everything downstream is unreliable.Why I never let Claude touch the store without a checkpoint
This isn’t a one-prompt operation. I run it with checkpoints built in. Before anything gets written to the store, I review the plan. Before a bulk update runs, I spot-check a sample of the output. There are approval steps before anything commits. The write guards in the MCP reinforce this too: dry-run is the default, and writes require explicit sign-off. The goal is to move faster without losing control of what’s actually happening in the store.
Matrixify is part of how this works in practice. When Claude prepares a bulk update, it formats the output as a Matrixify-ready spreadsheet. That file is the checkpoint. A spreadsheet is easy to review, easy to spot-check, and easy to understand at a glance before anything goes live. Once I sign off, it uploads to Matrixify and the changes execute. The format isn’t just a technical requirement. It makes the review step something you can actually do.
The first few passes with a new vendor or product type reveal gaps in what I explained, not failures in Claude. When an output is wrong, it’s almost always because I didn’t account for something in the rules I gave it. That’s useful feedback. It forces you to make your own logic explicit in a way that running on instinct never does.
What you have to teach Claude before it’s useful
None of this worked out of the box. The product title structure I use isn’t arbitrary: there are rules per vendor, rules per product type, edge cases learned from years of managing these catalogs. I can’t tell Claude to “optimize product titles” and expect it to know what I mean. I have to explain the structure, give examples, explain why the rules exist, and document the exceptions.
The same is true for tags. My tag taxonomy is standardized across stores with very different product types. Claude doesn’t know that taxonomy. I had to build it out, explain the mapping logic, and make sure the patterns were clear enough that it could apply them consistently to products it had never seen.
How my old Shopify SOPs became Claude’s training material
I’d already done a version of the groundwork before Claude was part of the picture.
Years of bulk importing and updating products through tools like Matrixify forces you to think in systems. Every time I mapped a new vendor’s catalog to my store’s structure, I had to make decisions: what does this product title become, which tags apply, what product type does this map to. Do that enough times and you start writing it down, not because you’re building infrastructure, but because you can only hold so much in your head. The result was a set of mini SOPs. Practical notes to my future self: here’s how vendor X structures their titles, here’s the mapping logic, here’s what to watch for.
I’d also built out the underlying frameworks those SOPs mapped to. A tag taxonomy with real logic behind it. A product type hierarchy I’d designed deliberately, thinking about SEO, storefront filter conditions, and how customers actually navigate a catalog. I’ve been doing SEO since 2007, and those fundamentals shaped how I structured everything long before AI was part of the workflow.
When I started using Claude for catalog work, those frameworks became the training material. I wasn’t asking it to invent structure. I was handing it structure that already existed and asking it to apply it consistently at scale.
Claude also pressure-tested what I’d built. Once it was running catalog work through my rules, it surfaced patterns I hadn’t explicitly documented: vendor quirks I knew intuitively but hadn’t written down, edge cases that fell between two rules. Some confirmed the logic I already had. Some prompted me to go back and tighten it. The frameworks I have now are more precise than the ones I started with, partly because explaining them to Claude forced me to make the implicit explicit.
How to start using Claude for Shopify ops today
You don’t need the same foundation in place to get going. The SOPs I handed Claude were built one vendor at a time, one problem at a time.
Pick your best-selling product type. Write down how a title should be structured for it and explain why. That’s one rule. Give it to Claude and ask it to apply that rule to a product that doesn’t currently follow it. The gaps in your explanation become the next rule. You build it forward from there, the same way I did, just with Claude in the loop from the start instead of added later.
The starting point is one thing you know well enough to write down. Most merchants already know more than they’ve documented.
The Shopify decisions I still make myself
Anything that requires judgment about the business: what to stock, how to price it, which vendor relationships are worth maintaining, what a customer complaint is actually telling me. Claude is good at applying rules consistently at scale. It’s not good at deciding what the rules should be.
The setup itself is also still on me. Encoding your catalog logic, your operational definitions, your store-specific conventions takes real work. It’s not a one-time cost either, because the rules evolve and the memory needs to stay current. But it compounds. Every hour spent making the rules clearer pays back every time a product gets processed correctly without your hands on it.
Claude does what you encode. If you’ve encoded your actual rules, it works well. If you haven’t, you get generic output that doesn’t fit how your store actually runs.
