An agent you can trust on a live store

Everyone's demo is the same: point a model at a product, get a paragraph of description back. That part was easy two years ago. The reason most Shopify catalogs are still full of half-finished product pages isn't that nobody can write the copy — it's that a real product page is dangerous to touch.

I run the product side of Sartoro, a custom-made menswear label — over two thousand products, each with its own configuration, all of it living in dynamic metafields and metaobjects. A page isn't a description and a photo. It's dozens of fields: fabric and care, SEO, taxonomy attributes, listing filters, cross-sell references, quick-switch wiring, and the configurator data that drives price and the finished garment. Most of it was written by other systems, and the defaults call out to apps in the background. Get one value wrong and you don't get an error — you get a broken price rule, a broken filter, or a wrong output, silently, on a page that's live and taking orders.

So the pages sit in draft. Hundreds of them. Not because the work is hard, but because it's tedious, high-stakes, and unforgiving all at once.

Just learning the store is its own project

Before you can fill anything, you have to understand the machine. When I started, the real work wasn't writing — it was mapping. What is each metafield, what's a metaobject, where is it used, what does it attach to, where does it get called out on the storefront, and how exactly do you fill it so the theme actually reads it. None of that is obvious from the admin. You learn it one broken page at a time.

That learning curve is a hidden cost nobody prices in. It's also the thing that, once written down, becomes the most valuable asset in the whole project — more on that below.

How many options does one product actually have?

More than you'd guess. A single custom suit is dozens of decisions — fabric, lapel, buttons, vents, pockets, lining, monogram, and on — and a "suit" is really three linked products underneath: a jacket, trousers, and a vest, each carrying its own set. Now do it again for shirts, and again for separates. Then add the swatch books and swatch-book sets, the quick-switch strips that let a customer flip between fabrics and colours, and the store features hanging off all of it.

That depth is the point, not an accident. Sartoro sweats product options harder than most of the custom-tailoring market — real, honestly-configured choices, not decorative dropdowns — and it's a big part of why people buy. It's also exactly what makes the setup punishing.

Multiply it out and a single launch isn't a few fields — it's hundreds of things that each have to be exactly right, because they're wired to price and to what the customer actually receives. At that complexity, occasional mistakes aren't a discipline problem. They're a maths problem. No human fills hundreds of interdependent fields, across dozens of products, without something slipping.

Last year I pushed a luxury line live by hand. It took the better part of six months.

What can an agent actually do inside Shopify?

More than write copy. On a live catalog, a well-built agent can:

• Audit every page against a schema — score what's filled, flag what's missing, write nothing. You finally know the true state of the catalog instead of guessing.
• Draft the real content — the description, the SEO title and meta to length, fabric and care, the image alt text, the listing one-liner — in the store's own conventions, copied from real reference products, never invented.
• Wire the mechanical stuff — set the category, attach the right taxonomy attributes, add it to the correct collections, point the quick-switch and swatch fields at the right variants. The fiddly, click-heavy admin nobody enjoys and everybody gets slightly wrong.
• Handle images at catalog scale — map a folder of photos to the right product, order the gallery the way the theme expects, upload it, and audit live-versus-expected.
• Read the theme — know which fields the storefront actually renders, so it never fills something that changes nothing, and never believes it changed something it didn't.

None of it is exotic. It's the Shopify Admin API and a few hundred lines of plain Python. The hard part isn't capability — it's doing all of it without breaking the 90% of the page you weren't asked to touch.

What makes it safe enough to run?

This is the actual product, because "let AI edit your store" should make you nervous. Every write goes through the same gates:

• Read before write. Fetch the live product first — never act on memory or a stale copy.
• Snapshot before write. The full current page is saved first. No snapshot, no write.
• Diff and approve. You see a field-by-field old → new, and only the fields you approve get written.
• Allowlist only. The agent touches a short list of content fields. Price, inventory, product status, the configurator, and every app namespace are hard-blocked — by code that refuses, not by good behaviour.
• One at a time. No silent bulk edits. Bulk means a canary of one, verified live, before the rest.
• Everything is reversible. Each change is logged and can be rolled back from its snapshot.

The lesson underneath all of it: on a live store, additive and reversible beats clever. A single "shared" record — one fabric's spec — can be wired to dozens of products at once; edit it naively and you've quietly changed every one of them. The guardrails exist because a store is a system of wired-together assets, not a spreadsheet. Most of the engineering went into the refusing, not the writing — I pulled that discipline apart into a reusable pattern in letting an agent write to production.

Here's the part that still unsettles me a little: for the small, scattered mistakes, I trust the agent's output more than my own. Give it one correct workflow and it runs that workflow the same way on the hundredth product as the first. I don't. A second agent whose only job is to double-check the first is the obvious next step — but even without it, a machine running a verified path beats a tired human running it from memory.

The description problem, specifically

The launch deadline is where quality quietly dies. Last year, to make a date, I did what a lot of people do: I used Shopify's built-in "generate a description" feature. It works, in that words appear. But the output repeats itself across products — the same shapes, the same phrases — so the pages read as boring, and worse, Google treats near-duplicate descriptions as near-duplicate pages. Some didn't get indexed. The ones that did, ranked poorly. Which makes sense: if every product says the same thing, there's nothing to distinguish one from another.

An agent fixes this at the root because it writes per product, from that product's real attributes, to real keywords, in an answer-shaped structure — unique copy that a search engine (and an AI answer) has a reason to surface. Getting the catalog written properly isn't cosmetic. It's the difference between existing in search and not. (The full playbook: generative engine optimization, end to end.)

Why do this as early as possible?

Three reasons, and they all compound.

The backlog compounds. Every month those pages sit in draft is a month of products that can't be found, can't rank, and can't sell. New products arrive faster than anyone fills them by hand, so the gap only widens. Starting late means starting bigger.

The knowledge compounds — and that's the real asset. The code took a few days. The map — which fields the theme reads, which values are fixed picklists, which records look shared but aren't, every trap that caused a real error — took longer, and it's what's actually valuable. Once it's written down, a cheap, small model can run the recurring work mechanically and safely. You're not building a script; you're building an institutional memory of your own store that gets more valuable every time you use it. That's the whole marketing-engineering bet in miniature: the leverage is in the system you keep, not the task you finish.

AI search is opening now. Machine-legible product pages — clean structured data, real specs in real fields, answer-shaped content — are the ones surfaced inside AI answers and shopping results. That window is opening, not open. Filling your catalog properly is how you show up in the surfaces replacing the search box.

How much time does it actually save?

The honest headline: that luxury line took me the better part of six months by hand. This year, I pushed a whole collection with the agent in about a week. Same person, same store, roughly an order of magnitude faster — and I'm not exaggerating when I say that even if I were a machine, I couldn't fill fields as fast as the agent does. It's not close.

Per page, the maths is simple. By hand, one product — copy, SEO to length, a dozen-plus metafields, category and taxonomy, the gallery in the right order, collections, variant wiring — is 30 to 60 minutes of careful admin, and you still miss things because there are too many to hold in your head. With the agent, the mechanical 90% is instant; your job shrinks to reading a diff and saying yes. Call it a few minutes a page.

But the minutes aren't even the point. The point is the pages actually get done — correctly, consistently, reversibly — instead of staying in draft forever because doing them by hand felt too risky and too slow. For any brand that needs to launch fast, or any store with a constant stream of new products, this setup step is the bottleneck. Removing it is worth more than the hours it gives back.

The honest caveat

This isn't an autonomous store manager, and it shouldn't be. It never sets a price, never touches stock, never publishes a product live, and never writes a field without a human yes on the diff. That's not a limitation to fix later — it's the design. The win isn't removing the human; it's removing the 90% of the work that made the human avoid the job entirely.

I set up every product on sartoro.co myself — which is exactly why I wanted this built. If you run a Shopify catalog with more products than you've had time to finish, start now: small, guard-railed, one page at a time. The catalog won't fill itself, and every month you wait, the pile gets taller.