AI Product Descriptions at Scale: A Shopify Bulk Generation Pipeline

Most Shopify catalogues carry a few winning product pages and a long tail of thin, duplicated, or empty descriptions. Rewriting them by hand takes weeks you do not have. An LLM can draft all of them in an afternoon, but only if you ground it on real data and never let it publish unchecked.

This is the pipeline I build for clients: structured attributes in, on-brand SEO copy out, human approval before a single write hits the Shopify Admin API.

Who This Is For

• Shopify merchants with hundreds or thousands of products and inconsistent descriptions.
• Stores where the same boilerplate copy is duplicated across dozens of variants.
• Teams that want to improve conversion on product pages without hiring a copywriting agency.
• Anyone who has tried a one-click AI app and been burned by invented specs or generic filler.

What You Will Need

• A Shopify store with Admin API access (a custom app with read_products and write_products scopes).
• Clean, structured product data: titles, specs, materials, tags, collections. The cleaner your inputs, the better the output.
• An LLM API key (this example uses Claude via the Anthropic API).
• A short brand voice brief: three or four sentences plus a couple of example descriptions you are proud of.
• A review surface: even a spreadsheet or a simple admin tab works to start.

The Pipeline

The core idea is a one-way flow from data to draft to review to publish. Nothing is written back to Shopify automatically. Generation is cheap; a bad description on a live product page is expensive.

Each stage does one job. Pull the attributes, assemble a prompt that carries only real data, generate a draft, run automated checks, stage it for a human, and only then write it back. If a draft is rejected, it loops back for regeneration with feedback. It never sneaks through.

This mirrors the data-first approach I cover in improving ecommerce conversion with data and automation: automate the tedious work, but keep a human on the decisions that matter.

Grounding on Real Attributes

The single most important rule: the model may only write from data you actually hold. If a hiking boot’s material is not in your catalogue, the description does not mention the material. Full stop.

In practice that means building a compact, structured record per product and passing it verbatim into the prompt:

• Title and product type
• Explicit specs (dimensions, weight, capacity, technical values)
• Materials and composition
• Tags and collections for context
• Any existing bullet points worth preserving

Everything the model writes must trace back to one of these fields. No field, no claim.

Prompt Design

A good prompt does three things: it hands over the grounded attributes, it states the brand voice, and it forbids invention in explicit terms. Here is a concise Python sketch that builds the prompt and stages the output for review rather than publishing it.

import anthropic

client = anthropic.Anthropic()

BRAND_VOICE = (
    "Warm, plain-spoken, confident. Short sentences. British spelling. "
    "Lead with the benefit, then back it with a spec. No hype, no emoji."
)

def build_prompt(product: dict) -> str:
    attrs = "\n".join(f"- {k}: {v}" for k, v in product["attributes"].items())
    return (
        f"Write a product description using ONLY the attributes below.\n"
        f"Never invent specifications, sizes, or materials. If a detail is "
        f"missing, leave it out — do not guess.\n\n"
        f"Brand voice: {BRAND_VOICE}\n\n"
        f"Product: {product['title']}\n"
        f"Attributes:\n{attrs}\n\n"
        f"Return: a 40-70 word paragraph, then 3 benefit-led bullet points. "
        f"Weave in the primary keyword '{product['keyword']}' naturally."
    )

def draft_description(product: dict) -> dict:
    message = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        thinking={"type": "adaptive"},
        messages=[{"role": "user", "content": build_prompt(product)}],
    )
    body = "".join(b.text for b in message.content if b.type == "text")
    return {
        "product_id": product["id"],
        "draft": body,
        "status": "pending_review",   # never "published"
        "grounded_on": list(product["attributes"].keys()),
    }

The output is a review record, not a live update. The grounded_on field keeps a trail of exactly which attributes fed the draft, which is useful when a reviewer or an auditor asks where a claim came from.

Keeping Brand Voice Consistent

Voice drifts when every prompt is slightly different. Fix it in two places. First, a single frozen brand-voice string shared across every product so the tone is identical batch to batch. Second, one or two example descriptions from your best pages, passed as few-shot examples. The model matches the register far more reliably from examples than from adjectives.

Resist the urge to over-instruct. A tight brief plus two good examples beats a paragraph of style rules that the model applies unevenly.

The Review Gate

This is the part cheap tools skip, and it is the part that protects your store. Before anything reaches Shopify, every draft passes through automated checks and then a human.

The automated layer catches the obvious failures cheaply: does every spec-like phrase in the draft correspond to a real attribute, is the length in range, is the keyword present without stuffing. Anything that passes is queued for a person, who approves in bulk with a quick scan. Rejections carry a reason back into regeneration.

You do not review every word forever. Once you trust the outputs on a product category, approvals get fast, but the gate stays.

Writing Back to Shopify

Only approved records are written, and only via the Admin API with a clear audit trail. Each write-back records who approved it, when, and which draft version went live. Batch the writes, respect the API rate limits, and log every mutation so you can roll back a category if something looks wrong post-publish.

Keep the previous description stored against each product before you overwrite it. Cheap insurance, and it makes the before/after comparison in the next section trivial.

Measuring Impact

Generating copy is not the goal. Selling more is. Treat the rollout as an experiment, not a launch. Split a product category: half get the new descriptions, half keep the old, and you measure conversion rate, add-to-cart rate, and time on page over a fair window.

	Manual copywriting	The pipeline
Throughput	10-20 products/day	Thousands of drafts/day
Cost per description	High (agency or staff time)	Low (API + review time)
Voice consistency	Varies by writer	Fixed by shared brief
Spec accuracy	Depends on the writer	Enforced by grounding + checks
SEO coverage	Ad hoc	Keyword-aware by default
Rollout speed	Weeks	Days

Run the split test properly. This is exactly the discipline I lay out in A/B testing to optimise product pages. Roll out to the winners, and fold the conversion numbers into your regular reporting so the wins are visible, as covered in automated Shopify sales and inventory reporting.

Failure Modes to Avoid

• Hallucinated specs. The model states a material, size, or certification you never gave it. This is the cardinal sin. It erodes trust and invites returns or complaints. Ground strictly on real attributes and check every claim.
• Generic copy. Bland, interchangeable descriptions that could belong to any product. Usually a symptom of thin input data or an over-loose prompt. Feed richer attributes and tighten the brief.
• Publishing without review. Auto-pushing thousands of unread drafts live. Even a 2% error rate across 3,000 products is 60 broken pages. The review gate is not optional.

What to Build First

1. Export and clean your product attributes for one category. Get the input data right before anything else.
2. Write the brand-voice brief and pick two example descriptions.
3. Build the grounded prompt and generate drafts for that one category into a review queue.
4. Add the automated checks: spec-to-attribute matching, length, keyword presence.
5. Review and approve a first batch by hand, then write those back via the Admin API.
6. Split-test that category against the old copy and read the conversion numbers before scaling.

Final Take

AI makes bulk product descriptions fast, but speed is not the hard part. Trust is. Ground every draft on real product data, never let the model invent specifications, and keep a human approving each batch before anything reaches a live page. Do that, and you turn a long tail of thin descriptions into a measurable conversion lever. Skip the guardrails, and you scale your mistakes as fast as your wins.