Search “shopify seo audit” and you mostly get two things: an app promising a one-click score, or an agency offering a free audit that turns into a sales call. Useful, sometimes. But neither shows you the actual method, and almost none of them check whether your pages are ready for AI search.

I audit my own stores because I run the ad accounts and the SEO myself, so the audit has to be repeatable and honest, not a lead magnet. Below is the whole process: the rubric I score against, what it finds on a real catalog, the GEO half that standard audits skip, and the open-source tool I built so I do not have to do it by hand across hundreds of pages.

What is a Shopify SEO and GEO audit?

A Shopify SEO audit checks whether your pages can rank in Google: titles, structure, schema, internal links, speed. A GEO audit adds a second question that matters in 2026: can an AI system read and cite your pages? Both draw from the same content, so I run them as one pass rather than two.

The reason to combine them is overlap. Ahrefs, analysing 863,000 result pages, found that 38% of pages cited in Google AI Overviews also rank in the organic top 10 (Ahrefs, March 2026), and Google’s AI Mode alone passed 1 billion monthly users (Google, May 2026). Good SEO feeds AI citations, so a modern audit should measure both in one scorecard instead of treating GEO as a separate project. I wrote the full fix list in my Shopify SEO checklist; this piece is about the audit that tells you which fixes you actually need.

How do I score a store?

I score every page against a fixed 100-point rubric so the result is a number I can compare over time, not a gut feeling. Five categories, weighted by how much they move rankings and citations:

Product pages get the same treatment with one addition: a dedicated GEO and AI-citation category, plus a feed-safety check I will come back to. The rubric is also tier-aware. A 4,000-product mega-hub is judged differently from a 20-product sub-collection, because a hub needs filters and a curated structure that a small collection does not. The point of scoring first is boring but important: you cannot prioritize what you have not measured.

What does the audit actually find?

Here is the uncomfortable part, from a real run. When I scanned 250 collections on a store I operate, close to none had structured data and about 40% had no hero image. On the six pages I then scored in full against the rubric, the mean was 48 out of 100, and the worst, a hub with roughly 4,000 products, scored 38: no hero image, no filters, no schema. These are not fringe pages, they are the ones a catalog leans on.

What made it useful was that the same gaps repeated, which meant one fix would work at scale. Six gaps came up across the pages I audited, whether I scanned them shallowly or scored them in full:

The schema gap was the one that stung, because it is both a ranking and a GEO problem, and it mirrored my blog side, where roughly 300 of 309 posts scored near zero on schema too. When one gap appears on nearly every page, it stops being a page-by-page fix and becomes a template fix, which is exactly the kind of thing an audit is supposed to surface.

The GEO half of the audit, and what most SEO audits skip

A standard SEO audit stops at rankings. The GEO half asks whether an AI system can parse and trust the page. Four checks I always run, with the nuance the hype leaves out.

Schema, for machine-readability, not magic. I check that Product, Collection, FAQ, and Breadcrumb schema exist and match what the page shows. But I am honest about why: Google states there is “no special schema.org structured data that you need to add” for its AI features (Google Search Central, December 2025). Schema earns rich results and clean machine-readable facts. It is not a switch that forces a citation.

The llms.txt check. I open the store’s /llms.txt. On Shopify you likely already have one: Shopify auto-generates an /agents.md file, and /llms.txt mirrors it unless you add a custom template (Shopify, May 2026). The audit item is not “create one,” it is “check what Shopify already serves and customize it only if the default is thin.”

The robots.txt check. GEO fails silently if you block the bots that feed AI answers. The trap is Google-Extended: blocking it keeps you out of Gemini training but does not affect your Google Search ranking (Google). Default Shopify robots.txt names none of these, so they are allowed. Make that a deliberate choice, not an accident.

Product feed safety. On product pages I check that the Product and Offer schema mirror the visible price and availability exactly. Get it wrong and Google Merchant Center can disapprove the item, and an AI agent can quote a stale price, which is worse than not being quoted. This is the one GEO check that also protects your paid shopping feed.

What tools do I use, and the one I built

The honest, cheap answer first. Shopify Search & Discovery for the faceted filters most of my collections were missing. Google Search Console to see which pages already earn impressions, so I audit the ones with a pulse first. That covers the manual version.

The problem is scale. Scoring 250 collections by hand, then rewriting copy and schema for each, is not realistic for a solo operator. So I built claude-shopify-growth, an open-source Claude Code kit (MIT licensed). It has two modules, collections and products, four skills each, and it runs the exact audit above:

• collection-analyze scores one page on the 100-point rubric and lists the gaps.
• collection-audit-pipeline scans the whole catalog, then deep-scores the worst pages and hands back a prioritized queue.
• collection-content-deep writes the tier-aware copy, comparison table, and FAQ.
• collection-mega-hub-optimize chains those into an end-to-end run from baseline to a target score, refusing to ship a page that fails any of 18 hard checks: title over 60 characters, hallucinated internal links, missing schema, and so on.

The product module mirrors this and adds the feed-safety gate, where the schema price and stock must match the visible ones byte for byte before the page ships. It is free, so here is the unglamorous truth: two of those hard gates exist because they broke on my own store. An FAQ rendered empty on a live page because the schema was nested the way the examples show, when the theme wanted a flat question-and-answer array. Another time deep content saved correctly but never appeared, because the collection used a custom theme template the code did not check for. Both are now gates that stop the run. That is the difference between a tool built in a tutorial and one built on a store that has to make money. The kit reaches the store the same way I described in how I connect Claude to my Shopify stores, and it is the Shopify sibling of my open-source Google Ads audit skill.

Worth it if you run dozens or hundreds of collections and the manual audit has become the bottleneck. Skip it if you sell ten products and can score them by hand in an afternoon. The rubric above is the real asset; the kit just runs it faster and refuses to ship a page that fails a gate.

How do I prioritize the fixes?

An audit that hands you 200 issues is a to-do list nobody finishes. The value is ranking them, and the rule is simple: fix what moves the most pages for the least work first. On my store that meant three levers, in order.

1. One schema template edit. Because the JSON-LD gap was on nearly every collection, a single Liquid template change added structured data to more than 100 collections at once. Highest impact on the board.
2. Turn on faceted search. Most collections offered only a price filter. Enabling brand, type, and size facets fixed curation across the catalog from one app, not one page.
3. Bimodal copy. A 40 to 120 word intro above the grid plus a real FAQ below it, applied first to the collections that already earn impressions in Search Console.

Then I re-score, because an audit is not done until the number moves. Three collections I rebuilt this way went from 55, 52, and 52 on the rubric to 95, 96, and 95, and the biggest gains landed in the two categories the GEO layer cares about most: technical and schema, and SEO intent.

Frequently asked questions

What is the difference between an SEO audit and a GEO audit?

An SEO audit checks whether a page can rank in Google: titles, structure, schema, links, speed. A GEO audit adds whether an AI system can read and quote the page: machine-readable facts, answer-first passages, and crawler access. They share the same foundation, so I run them as one scored pass rather than two separate projects.

What tools do I need to audit a Shopify store’s SEO?

At minimum, Google Search Console to see what already earns impressions, and Shopify Search & Discovery for faceted filters. To score and fix at scale I use my own open-source kit, claude-shopify-growth, which runs the rubric and the fixes. A crawler like Screaming Frog also works for the pure technical pass.

How often should I audit my Shopify store?

A full catalog audit once or twice a year, plus a quick re-score of any collection you rewrite or that loses impressions in Search Console. The point is to catch template-level gaps, like missing schema, that silently affect every page at once.

Can I audit my store for AI search like ChatGPT, Perplexity, or AI Overviews?

Yes. Check that your key pages have accurate schema, answer-first copy, and a robots.txt that allows OAI-SearchBot, PerplexityBot, and Claude-SearchBot. Rank the page first, since AI answers heavily reuse top-ranking pages, then make it quotable. There is no paid shortcut.

Is the open-source audit tool free?

Yes, it is MIT licensed and free to use. It runs inside Claude Code and needs a Shopify MCP connector with Admin API access to read your store’s data and push the fixes. Your private product knowledge stays in a git-ignored folder and is never shipped.

The verdict: audit in this order

The whole audit is five steps, and the order is what makes it efficient:

1. Score each page on the rubric, so you have a number instead of a hunch.
2. Scan the whole catalog, so you find the gaps that repeat at the template level.
3. Add the GEO checks: schema accuracy, the llms.txt or agents.md file, robots.txt crawler access, and product feed safety.
4. Prioritize template-level fixes that touch 100 pages before the one-off tweaks that touch one.
5. Re-score to confirm the number moved before you call the audit done.

Half your future visibility is an AI answer, not a blue link, so the GEO checks are no longer optional. But the sequence matters more than any single step: measure, find the repeats, fix the template, prove it.

If you run a handful of collections, you can do this by hand with the rubric above. If you run hundreds, the tool is on GitHub and it is yours to copy. Either way, once the audit is done, my Shopify SEO and GEO checklist is the fix list to work through.

Search “shopify seo checklist” and you get a wall of solid, near-identical lists: title tags, alt text, sitemaps, page speed. All correct. All written before AI search mattered, and none of them mention it. Meanwhile a real share of my buyers now start a product question inside ChatGPT or Google’s AI answers, not a blue-link results page.

So this checklist has two halves. The first is the classic on-page work that still does the heavy lifting. The second is the GEO layer that decides whether an AI answer quotes your store or a competitor’s. I run both on stores I operate, and I build the open-source tooling that automates the boring parts, so everything below is what I actually do, not theory.

What is a Shopify SEO checklist in 2026, and why does it need a GEO layer?

A Shopify SEO checklist is the set of on-page and technical steps that make a store rank in Google. In 2026 it needs a second column, because ranking a page and getting that page cited in an AI answer are now two different jobs. Google’s AI Mode alone passed 1 billion monthly users (Google, May 2026), and ChatGPT reports around 900 million weekly users (OpenAI, reported February 2026).

The good news for anyone who has done SEO: the two jobs overlap heavily. Ahrefs, analysing 863,000 result pages, found that 38% of pages cited in Google AI Overviews also rank in the organic top 10 (Ahrefs, March 2026). Good SEO still feeds AI citations. GEO is not a replacement for the checklist below, it is a layer on top of it.

I did not learn this from a webinar. When I first audited my own store with a 100-point rubric I built, across a sample of 250 collection pages, the picture was ugly and consistent: roughly 40% of collections had no hero image at all, and effectively 100% were missing structured data. The mean score across my six deepest audits was 48 out of 100. That gap is exactly what this checklist closes.

SEO vs GEO: what actually changed?

GEO, sometimes written “AI GEO” or “generative engine optimization,” is the practice of making your content easy for AI systems to read, trust, and quote. The shift is the unit of value. Classic SEO competes to rank a whole page. GEO competes to have a specific passage lifted into an answer. Same content foundation, different finish.

Keep that overlap in mind as you read. Nothing in the GEO half asks you to undo the SEO half. It asks you to make the same page cleaner for a machine.

The classic Shopify SEO checklist (the foundation that still ranks)

This is the part every guide covers, so I will keep it tight and add what I actually saw break on a real catalog. Do all of it before you touch the GEO layer, because AI systems mostly cite pages that already rank, and none of this works if the fundamentals are missing.

1. One keyword-front title per page, under 60 characters. Put the term a buyer types first. On my store the biggest recurring gap was not bad titles, it was no consistent title convention across collections, so I enforce one template store-wide.
2. A written meta description. Six of my six deepest-audited collections had none, so Google wrote its own. Write your own for anything with commercial intent.
3. One H1, then a logical H2/H3 outline. Structure is not decoration. It is how both Google and an AI model figure out what a page is about.
4. Descriptive alt text on every product and hero image. Roughly 40% of my audited collections had no hero image at all, which is a ranking and a trust problem before it is an accessibility one.
5. Clean URLs and verified internal links. Every internal link should point to a real, live handle. When I automate this I verify each link against live store inventory so nothing points to a dead collection.
6. Collection and product copy with real depth. The pattern I kept finding was bimodal: pages had either zero body copy or a 300-word wall. The band that works is a 40 to 120 word intro above the grid, plus a genuine FAQ below it.
7. An XML sitemap, and no-index on thin or duplicate pages. Shopify generates the sitemap; your job is to stop indexing near-duplicate collections that split your own ranking signal.
8. Core Web Vitals and theme speed. Trim apps you do not use. Each one adds script weight that a buyer on mobile pays for.

If you want the deeper version of the collection-page work, I wrote a separate walkthrough on optimizing Shopify collection pages. The short version: fix structure, copy, and internal links first, because they are the base every AI system reads from.

The GEO layer nobody’s adding to their Shopify checklist

Most vendor blogs get the next part wrong, and I would rather trust primary sources than hype. The GEO layer is smaller and more boring than the “AI-powered” pitches suggest, and one popular tactic is, per Google, unnecessary. Add these five in order.

1. Structured data, for the right reason

Add schema to your key templates: Product, Collection, FAQ, and Breadcrumb. It makes prices, availability, ratings, and questions machine-readable, which is the whole game for AI. But be precise about why. Google states plainly that for its AI features there is “no special schema.org structured data that you need to add” (Google Search Central, updated December 2025). Schema earns you rich results and clean machine-readable facts. It is not a secret switch that forces an AI to cite you.

On the effort side, this is the highest-leverage item on the page. On my store, every audited collection was missing schema. I fixed all of them with a single JSON-LD template edit in the theme, which pushed the fix across more than 100 collections at once. On my rubric, the Technical and Schema category on a rebuilt collection jumped from 5 out of 15 to 14. One template, one afternoon, catalog-wide.

2. Answer-first copy that a model can lift

Open each important section with a direct 40 to 60 word answer, then expand. AI systems quote self-contained passages, so a section that answers its own heading in the first sentence is far more quotable than one that warms up for three paragraphs. Keep your product and brand names consistent too. Entity clarity, using the same name for the same thing every time, is how a model learns what you are.

Concretely, on a collection page I stopped opening with “Welcome to our collection of premium products” and started with “This collection has 120 gel polish colors, sorted by finish and brand, all in stock and shipping from the US.” The first version says nothing a model can use. The second answers the three questions a buyer and an AI both ask, what is here, how is it organized, and can I get it, in one sentence. That is the whole move, repeated across every page.

3. llms.txt on Shopify: what is real, and what Shopify already did for you

llms.txt is a proposal from Answer.AI (September 2024) for a plain-text file that tells AI tools what your site is about. It is a proposal, not an adopted standard, so treat vendor claims about it with care.

Two things most Shopify checklists get wrong here. First, Google says you do not need it: its 2026 guidance states you do not have to create llms.txt, “AI text files,” or special markup to appear in Search or its AI features (Google Search Central, updated June 2026). Second, if you are on Shopify you likely already have one. Shopify now auto-generates an /agents.md file, and /llms.txt plus /llms-full.txt mirror it unless you add a custom theme template (Shopify, May 2026). Open your-store.myshopify.com/llms.txt right now and you will probably see it.

I checked two stores I run, and they served two different files. The first was Shopify’s default: a short block of agent instructions that points AI shopping assistants at the Universal Commerce Protocol (co-developed by Shopify and Google, endorsed by Wayfair, Target, and Etsy) and tells them how to transact through the Shop skill. No products, just protocol. The second store served a customized version: a one-line store description, a keyword line, then a bulleted list of the main collections with their URLs, plus a “last updated” date. That second file is a plain map of the catalog, the kind of thing an AI can read in one pass to understand what the store sells.

Neither needed hand-coding. So the honest checklist item is not “generate an llms.txt.” It is “open your own /llms.txt, see which of those two you are serving, and write the catalog-map version only if the default does not describe your store well.”

4. Let the right AI crawlers in

GEO fails silently if your robots.txt blocks the bots that feed AI answers. This is the most misunderstood corner of the topic, so here is the cheat-sheet, from each vendor’s own documentation.

The trap is Google-Extended. Block it and you keep your content out of Gemini training, which is a fair choice, but it does not affect your Google Search ranking at all (Google). Plenty of store owners block it thinking they are protecting rankings. They are not. Default Shopify robots.txt names none of these bots, so they are all allowed. If you want to be in AI search, that default is fine. Just make the choice on purpose.

5. Product pages: schema that matches the shelf

Product pages are the money pages, and they carry a GEO rule the collection pages do not: the Product and Offer schema must mirror the price and availability a shopper actually sees, exactly. Get this wrong and two things break at once. Google Merchant Center can disapprove the item for a price mismatch, and an AI agent reading your structured data can quote a stale price to a buyer, which is worse than not being quoted at all. When I optimize a product page I gate on this: the schema price and stock status have to match the visible ones byte for byte before the page ships.

The other half is the copy. Manufacturer boilerplate is the same text on a thousand other stores, so it gives an AI no reason to cite you specifically. A benefits-first description with a real specs table, a “who it is for” line, and an honest FAQ gives both Google and a model something only your page has. Same discipline as the collection work, applied to the page where the sale happens.

What tools do I use to run this at scale?

Honest answer, cheapest first. Shopify Search & Discovery for faceted filters, which most of my collections were missing. Google Search Console to see which pages already earn impressions, so you optimize the ones with a pulse first. A theme schema edit for the catalog-wide JSON-LD fix above.

And the kit I built, because doing this by hand across hundreds of collections is not realistic. It is an open-source Claude Code project, claude-shopify-growth (MIT licensed), that scores a page on a 100-point rubric covering both SEO and GEO, then rewrites copy, builds the schema bundle, and verifies every internal link against live inventory. It refuses to ship a page that fails any of 18 hard checks: title over 60 characters, hallucinated links, missing schema, and so on.

I am not selling it, it is free, so here is the unglamorous part. Two of those hard checks exist because they broke in production on my own store. An FAQ rendered empty on a live page because the schema was nested the way schema.org examples show, when Shopify’s theme wanted a flat question-and-answer array. Another time deep content saved correctly but never appeared, because the collection used a custom theme template the code did not check for. Both are now gates that stop the run. That is what building on your own store teaches you that a tutorial cannot. The automation behind all of it is Claude talking to Shopify, which I covered in how I connect Claude to my Shopify stores.

Does the GEO layer actually work?

This is the part I have to be honest about, because my voice is not the hype kind. What I can put a file behind is a quality-score lift, not a traffic miracle. On my own 100-point rubric, the collections I started with averaged 48. Three I fully rebuilt using the same collection-page playbook plus the GEO layer scored 95, 96, and 95. The biggest category jumps were exactly the GEO-adjacent ones: Technical and Schema, and SEO intent match.

What about the AI citations themselves? Those pages now rank on page one and I do see them surfaced in AI answers and recommendations. But I will not hand you a citation-rate number, because I do not have a clean before-and-after measurement of it yet, and a confident wrong number is worse than an honest gap. Treat GEO as compounding, not instant. The score lift is the receipt I can show today; the AI-citation upside is the trend I am still measuring.

Frequently asked questions

What is the difference between SEO and GEO for Shopify?

SEO makes a page rank in Google’s results. GEO makes a page easy for an AI system to read and quote in an answer. They share the same foundation, structured, well-written, crawlable pages, but GEO optimizes for a passage being lifted into an AI response rather than a page ranking on its own.

Do I need an llms.txt file for my Shopify store?

Probably not by hand. Shopify auto-generates an /agents.md file, and /llms.txt mirrors it unless you customize the template. Google also states you do not need llms.txt to appear in its AI features. Check what your store already serves at /llms.txt, then customize only if the default does not describe your catalog well.

How do I get my Shopify pages cited by ChatGPT, Perplexity, or Google AI Overviews?

Rank the page first, since AI answers heavily reuse top-ranking pages. Then make it quotable: answer-first passages, consistent entity names, Product and FAQ schema, and a robots.txt that allows OAI-SearchBot, PerplexityBot, and Claude-SearchBot. There is no paid shortcut and no magic file.

Does schema markup help with AI search?

It helps by making your facts machine-readable and by earning rich results, which support rankings that AI answers draw from. But Google is explicit that no special schema is required for its AI features, so add schema for the real benefits, not because a blog promised it forces citations.

Is the classic SEO checklist still worth doing in 2026?

Yes, and it is still where most of the return is. Roughly 38% of pages cited in Google AI Overviews also rank in the organic top 10, so classic SEO is the on-ramp to AI visibility, not a separate track you can skip.

The verdict: what to do, in order

Do the eight classic items first. They are table stakes and they feed everything else. Then add the GEO layer in this order for the fastest return: schema across your key templates (one theme edit, catalog-wide), answer-first copy on your top pages, a quick look at what Shopify already serves at /llms.txt, and a robots.txt you have chosen on purpose. Skip the paid “GEO tools” that promise citations for a fee, because the two authorities that matter, Google and your own analytics, both say the work is structure and clarity, not a magic file.

If you run more than a handful of collections, the checklist stops being a manual job. That is the gap my open-source kit fills, and it is yours to copy. If you would rather see the paid-side of my operator work, I also wrote up the wasted spend I found auditing my own Google Ads. Same principle either way: run it on a real store, publish the receipts.

Why I built this skill instead of just running prompts

Most Shopify stores past their first year have a hidden problem in their collection pages. The product detail pages (PDPs) get attention. The blog gets attention. The collection pages, the ones that sit between the home page and the products, often look like this:

• An H1 that says BRAND - All products or just the brand name in all caps
• No body content, just the product grid
• A meta description that Shopify auto-generated from the first product title
• No FAQ, no schema beyond the default Shopify ItemList
• Zero internal links from this page out to anything else

I have one brand with over 200 collection pages built up over eight years. I sampled six of them with an audit script and the mean composite score was 48-65 out of 100. That is “the page exists but Google has no reason to rank it and an AI assistant has no clean passage to cite.”

The naive fix is to write better content for each page by hand. At roughly 2 to 3 hours per hub including audit, copy, schema, internal linking, and testing, that is 400 to 600 hours of work for one brand. Unscalable.

The alternative is a skill. A Claude skill is a self-contained markdown file with a prompt, a workflow, and hard gates that block the workflow from continuing if any quality check fails. You invoke it with a single command and the same procedure runs the same way on every hub. The gates are the part that matter most because they encode every lesson you have already paid for.

What a Claude skill is, in 60 seconds

If you have used Claude Code, you have probably been invoking skills without thinking about them. A skill is a folder under ~/.claude/skills/[skill-name]/ with a SKILL.md file at the top. The frontmatter declares the skill name, a description, and a trigger phrase. The body is the workflow Claude follows when the skill is invoked. (If you have not connected Claude to Shopify yet, my three-path MCP setup guide walks through the connector layer this skill depends on.)

Reference: Anthropic Claude Code Skills documentation.

Here is the minimum mental model:

• Skill folder: the unit. One folder, one skill, one purpose.
• SKILL.md: the prompt + workflow + hard gates. Versioned. Editable.
• references/: supporting markdown the skill loads on demand (templates, schemas, examples).
• scripts/: helper Python or bash the skill calls (verify scripts, push scripts).
• Invocation: slash command or natural-language trigger in any Claude session.

Why this beats keeping the same instructions in a long prompt or a Notion doc:

1. Gates are enforceable. You can write “do not use the word delve” in a prompt and Claude will sometimes still write delve. You can write the same rule in a skill as a hard gate that checks the output and refuses to proceed. The skill blocks itself before the bad output reaches you.
2. The skill is versioned. When you catch a new failure mode, you add a gate, bump the version, and every future invocation has the lesson baked in.
3. The skill is portable. Drop the folder onto any operator’s machine and they have the same workflow.

The collection skill I built is exactly this shape. One folder, one SKILL.md, a few reference templates, and a notify script. Total roughly 600 lines of markdown.

The 12 steps inside the skill

The full skill runs 12 steps end-to-end. I will summarize each in one sentence and call out what is unusual.

Step 0.5: Knowledge base factcheck (HARD GATE 0)

Before any writing happens, the skill greps a local product knowledge base for the product line being optimized. The KB is the highest-authority source because it has the first-party facts: best-seller status, target customer, upsell pairings, discount margin. The skill refuses to write content if it has not loaded KB facts into working memory first. This gate exists because the first time I skipped it I shipped seven hallucinated facts about a top-selling product line. The KB had every correct fact the whole time.

Step 1: Baseline pull, three sources in parallel

Pull from the Shopify Admin GraphQL (collection metadata, metafields, current schema), the live page (DOM, current title length, current schemas), and Search Console (90-day impressions, clicks, top queries). All three feed a baseline snapshot JSON the skill diffs against later.

Step 2: Tier detection and brand mapping

Classify the collection: mega-hub, brand-hub, sub-collection, or tool-tier. Pull every related sub-collection from the Shopify catalog so the skill knows which handles exist. Hard gate: the skill is never allowed to write an internal link to a handle that was not in this pull. This gate exists because in an earlier round I hallucinated handles that looked plausible but returned 404. Reader trust evaporates fast on broken internal links.

Step 3: SEO title rewrite with brand-suffix opt-out

Most Shopify themes append " - {Store Name}" to every page title. On a brand-hub that looks like "OPI GelColor - Store Name" which wastes 12-15 characters on duplicate branding. The skill sets a boolean metafield custom.suppress_brand_suffix = true and rewrites the SEO title to 55-60 characters of full keyword and unique selling point. The theme reads the metafield and skips the suffix.

Step 4: Meta description, 120-160 characters, no AI-trigger phrases

The skill maintains a banlist of phrases that scream AI-written: delve into, navigate the landscape, in today’s fast-paced, in conclusion, flawless, explore. The gate scans the output and refuses to proceed if any banned phrase appears. Replacement vocabulary is action verbs the catalog actually uses: shop, browse, get, stock, compare.

Step 5: H1 fix if generic

If the collection title is “BRAND” or “Brand – All products,” rewrite it. Renaming the title cascades to the H1, the breadcrumb, and the internal anchor text from PDPs. Verify the navigation menu uses a separate linklist label or this step risks renaming the nav too.

Step 6: Deep content, tier-aware section template (1,500-2,500 words)

This is the largest step. Different category tiers use different section templates. The skill ships six templates because gel collections, tool collections, bundles, seasonal duos, bulk-save tiers, and nail art each have different reader intent and different competitive sets.

A gel/polish collection uses the 8-section template: overview, brand spotlight, how to pick, comparison table, application guide, care, wholesale, related. A tools collection adds extra sections for specs comparison, bit compatibility, safety workflow, and maintenance. A bundle collection focuses on bundle composition value math.

The content is written in the store’s own voice as if the merchandising team wrote it. Hard gate 12 forbids any phrase that exposes the internal workflow: no “the KB notes,” no “per our internal data,” no “according to our knowledge base.” Salon technicians do not know what a KB is. The voice has to read like a human merchandiser wrote it from memory.

Step 7: Internal linking, three layers, 12-20 links per hub

Layer A wraps the brand H3 headings in <a href> tags pointing to brand sub-collections. Layer B wraps the first cell of every comparison table row in the same link. Layer C is a new H2 called “Related collections” with 5 cross-hub teasers placed before the “Related reads” block. Total 12-20 internal links per page, every single one verified against the Step 2 inventory.

Step 8: FAQ as a flat metafield (not a schema.org wrapper)

The store theme reads the FAQ metafield as a flat array of {q, a} objects. The theme builds the FAQPage JSON-LD wrapper itself from the flat data. If you put the schema.org wrapper directly in the metafield, the theme renders three empty FAQ accordion boxes with no question text inside. I shipped this bug once on a major brand-hub before I added gate 15 (FAQ live render verify) which catches it in 3 seconds via a curl + grep.

Step 9: Push metafields in a single batched mutation

One metafieldsSet mutation pushes the deep content HTML, the FAQ flat array, the brand-suffix boolean, and any sub-category list together. Batching matters because Shopify rate-limits per-call and a 4-field push as one call is 4x cheaper than four sequential pushes.

Step 10: Apply the hybrid section template

Push a templates/collection.{handle}.json with the proven section order: main banner, sub-nav, product grid, FAQ accordion, deep content. Order matters for both readability and crawl: the FAQ sits right under the product grid which is where users scroll first, content sits at the bottom for users who need depth.

Step 11: Pre-publish verification (5 checks)

Five gates run before the skill marks itself successful: em-dash count zero, AI-trigger phrase count zero, HTML title under 60 characters on the live page, all internal /collections/ links return 200, all internal /blogs/articles/ links return 200. The link sweep is delegated to a cheap Haiku sub-agent because verifying 20 URLs does not need a frontier model and saves the main session’s context budget.

Step 12: Live composite re-score and Telegram notify

Run the audit skill against the live URL and confirm composite score crossed 85. Send a Telegram message to my production channel with the hub handle, tier, before/after composite, and a one-line summary. The notify is mandatory because production events need visibility alongside blog publishes. A skill that ships changes silently is a skill that lets regressions accumulate unnoticed.

The 15 hard gates, each from a real failure

The gates are the institutional memory. Every gate exists because I shipped a bug, you caught it (or my own audit caught it), and the only way to prevent it from happening again is to encode the check into the skill itself.

Here are the five gates that matter most and the failure each one prevents:

• Gate 0, KB factcheck first. Failure: I shipped seven false facts on a top-selling product line because I pulled Shopify titles and guessed the rest. The KB had every correct fact. Gate forces a grep on the KB before any writing starts.
• Gate 4, Zero em-dashes in deep content. Failure: em-dash density above 0.3 per 100 words flags as AI-written in most modern AI detectors. Gate runs reduce_emdash.py before push and refuses to proceed if any em-dash survives.
• Gate 12, No internal source labels. Failure: content that says “the KB notes” or “per our database” reads like a customer service script. Gate scans output for KB / database / our records phrasing and rewrites to direct facts.
• Gate 14, Telegram notify mandatory. Failure: I optimized hubs silently for two weeks and lost track of which were live, which were rolled back, which had hero images pending. Gate sends a structured notification per publish so the production channel is always the source of truth.
• Gate 15, FAQ live render verify. Failure: schema.org FAQPage wrapper in the metafield instead of flat {q, a} = three empty FAQ boxes on the live page. Gate curls the live URL and greps for actual question text. Blocks Telegram notify if FAQ DOM is empty.

The other 10 gates cover URL inventory verification, title length, schema bundle completeness, tier-aware content depth, hero image policy, and similar boring-but-load-bearing checks. Every gate adds maybe 30 seconds to skill runtime. The cost is trivial. The protection is enormous.

How I test the skill actually works

Three test loops run on every hub the skill touches, with results pulled at 30, 60, and 90 days post-publish.

Loop 1: Search Console diff

Pull 90 days of impressions, clicks, average position, and top queries from Google Search Console for the hub URL before optimization. Wait 30 days, pull the same 90-day window post-publish. Compute deltas. The hubs I have tested show consistent gains in impressions and average position, with click-through following at a slight lag because new content needs time to win SERP attention.

Loop 2: Composite score audit

Run the collection-analyze skill against the live URL before and after. This is the 100-point scorecard the skill targets. Pre-optimization composite is in the 48-65 range across the hubs I sampled. Post-optimization composite is consistently 85+ which is the hard gate threshold the skill enforces.

Loop 3: SERP rank track on top 5 queries

Pull top 5 queries the hub already ranks for from Search Console, then track SERP position for those queries weekly via a DataForSEO live SERP pull. This catches the case where impressions go up because of new long-tail surface area but the head terms regress. I have not seen a regression on the 12 hubs so far.

What the test loop does not measure

Conversion rate is not in the test loop because attribution from collection page traffic to revenue is messy on wholesale stores. I track aggregate revenue trend at the brand level but I do not claim individual hub optimization caused individual revenue lift. The skill optimizes for SEO and GEO. Revenue lift is the downstream consequence I cannot cleanly isolate.

Results across the 12 hubs I have shipped

Two batches so far:

• Batch 1 (7 mega-hubs): the largest, highest-traffic brand-hubs on the store. Mean composite before: 48-65. Mean composite after: 85+. Impression lift trending +30-40% in the 30-90 day window. Time to ship per hub: 2-3 hours of active operator time per hub, most of that reviewing AI output and approving live publishes.
• Batch 2 (5 brand-hubs selected from GSC opportunity data): hubs with high impressions but low CTR and average position above 10. Same skill, same gates, same composite lift pattern. Brand-hubs are lighter than mega-hubs so time to ship dropped to roughly 90 minutes per hub.

Cost: Claude API spend per hub is in the low single dollars, dominated by the deep content generation step. Total skill spend across all 12 hubs is well under $50. The bigger cost is operator time on review and approvals, which is the right place to spend operator time.

I am not publishing absolute traffic numbers per hub because the store competes in a specific niche and giving competitors a free read on which hubs lifted by how much would be operator malpractice. The pattern is consistent enough that I am willing to bet the same skill on the remaining 200+ hubs.

Now scaling to the remaining 200+ collections

With 12 hubs proven, the next phase is rollout. Three principles:

1. Tier priority. Mega-hubs first (highest traffic potential), brand-hubs second (medium traffic, often easier wins), sub-collections last (low individual impact but lift the brand-hub authority through internal linking when done correctly).
2. Batch via the audit pipeline. The collection-audit-pipeline orchestrator runs collection-analyze across every collection, sorts by composite score ascending and traffic potential descending, and feeds the worst-but-most-valuable hubs into collection-mega-hub-optimize in batches of 5-10 per session.
3. Gate enforcement holds. Every hub goes through the same 15 gates. No exception for “just this one” no matter how small. Skipping a gate once is how the skill stops being trustworthy.

Target for the next 90 days: 50 hubs through the skill at the rate of roughly 15-20 per month. That covers all mega-hubs and the top brand-hubs in the brand. Sub-collection rollout is the second quarter.

What I learned building this skill

Three meta-lessons that apply beyond this specific skill:

1. Production failures are the spec. Every hard gate in the skill exists because something broke in production and the fix had to be encoded so it could never break the same way again. If you are building a skill and you cannot point at a real failure each gate prevents, the gate is probably premature.
2. Skill beats prompt at scale. A long prompt re-pasted into 12 conversations is 12 chances for one detail to drift. A skill invoked 12 times is the same workflow 12 times. The latter is auditable, the former is not.
3. Per-tier templates beat one-size templates. A gel collection and a tools collection and a bundle collection have different reader intent and different competitive sets. Trying to write the same content template for all three produces mediocre output for all three. The skill ships six different section templates indexed by tier.

When this skill fits, and when to skip it

You will get value if:

• You run a Shopify store with 50-500 collection pages
• Most of your collection pages are thin (no body content, no FAQ, generic title)
• You have a product knowledge base or are willing to build one (brand spec sheets, sales scripts, target customer profiles)
• You are on Shopify Advanced or Plus where metafields and theme template overrides are available

You should skip if:

• Your store has fewer than 50 collections (do it manually, the audit overhead is not worth it)
• You have no product knowledge base and no time to write one (the skill refuses to write content without KB facts)
• You are on Shopify Basic without theme template override access
• Your collection pages are already deep and well-scoring (audit first, do not over-engineer what already works)

If you want me to run this on your store

I am working through the remaining 200+ hubs on my own brand and I have bandwidth for a small number of operator projects in parallel. If you run a Shopify store and your collection pages match the “thin grid, generic title, no schema” pattern I described above, send me a note with your store URL and a rough collection count. I will reply with a free composite-score audit on 5 of your hubs so you can see what the skill catches before deciding anything else.

Email: [email protected]. Subject line “collection audit” so it threads correctly.

FAQ

Is the skill open source?

The collection skill lives inside the broader Claude Growth Kit toolchain. The kit itself is paid (I reviewed it here). The collection-specific skill is something I built on top of the kit’s primitives, the kit does not ship with Shopify-specific skills. If you have the kit installed, you can clone my skill folder onto your install and run it against your store.

How long does the skill take per hub?

Active operator time is 90 minutes to 3 hours per hub, depending on tier. Most of that is reviewing AI output and approving live publishes. The skill itself runs in 10-20 minutes of Claude session time, but the operator-in-the-loop decisions (does this hero pick fit, is this internal link the right cross-hub, is this FAQ phrasing on brand) are the slow parts and they should be slow.

Does this work on Shopify Basic?

Partially. The deep content metafield works on every plan. The theme template override and the brand-suffix metafield opt-out require either Shopify Advanced (Online Store 2.0 sections everywhere) or Plus. On Basic you can still ship the content, but the title and template wins are gated on plan upgrade.

What if I do not have a product knowledge base?

You build one. The minimum viable KB is a markdown file per product line with: positioning, top 3 best sellers, target customer, technique workflow, upsell pairings, and competitive comparison. Two to four hours per product line. The skill is dramatically better with a KB than without, so investing the time pays back across every hub the skill ever touches.

Can you share the skill source?

Yes, for operators I am actively working with. I would rather walk through the skill on a call with operators who have context on their own store than drop a 600-line markdown file in a public repo where it is one Twitter screenshot away from being misused on stores it was not designed for. Email me if you want to see it.

What is the next skill you are building?

A multi-store inventory sync skill that handles a category I keep solving by hand: when two of my brands carry overlapping SKUs, keeping stock counts and reorder triggers in sync without double-counting. Same shape as this skill (workflow + gates + Telegram notify). I will write it up the same way.

Updated July 2026 with how I actually connect across multiple stores, and why the built-in connector is not it.

Why this matters if you run a Shopify store

The promise of AI for ecom operators is straightforward: ask a question in plain English, get an answer that pulls real data from your store. “Which products lost stock this week?” “Show me orders over $200 from California in the last 30 days.” “Which collections have no description tag?”

Without MCP (Model Context Protocol), Claude can only guess. It does not see your store. You paste a CSV, it answers, you paste another CSV, it answers again. The loop is slow and the data is always stale.

With MCP, Claude reaches into your Shopify Admin API directly. You ask, it queries, it answers, all in one turn. No CSVs. No spreadsheets. No copy-paste between tabs.

The reason most operators have not done this yet is the perception that MCP is a developer thing. You read the spec, you see TypeScript, you bounce. I bounced too, twice. Then I realized you do not need to build an MCP server. You install one that already exists, and you wire it to your store with a token.

What MCP actually is, in 60 seconds

Think of MCP as a universal adapter between Claude and any system that has an API. Shopify has an API. Google Search Console has an API. Stripe has an API. Each one normally needs a custom integration. MCP standardizes the wiring so Claude can talk to all of them through one protocol.

An MCP server is a small program that translates between Claude’s protocol and a specific API. Someone wrote the Shopify MCP server. Someone wrote the GSC MCP server. You do not have to write either. You install them and tell them how to authenticate to your store.

That is the entire mental model. Once it clicks, the setup is almost boring.

Heads-up: Shopify deprecated the “Develop apps” shortcut on January 1, 2026

If you searched this topic 8 months ago, you would have hit a one-click path called “Settings → Apps and sales channels → Develop apps”. That path is now retired for new apps. Shopify’s official notice:

“As of January 1, 2026, you can no longer create new legacy custom apps. This does not impact any existing apps.” (Shopify Changelog)

If you already have a legacy custom app installed (a token starting with shpat_), it still works. Do not delete it; you cannot recreate it as legacy. If you are starting fresh today, pick one of the three modern paths below.

Three modern paths, pick the one that fits

All three end in the same place: Claude can read your store. They differ in how much setup time you accept up front.

Here is what I actually run, and why. If you have one store, use Path A, the connector. It is the fastest and it is what I recommend to most operators I onboard. But I run several stores, and the built-in connector makes you switch the active store every time you change context. That got old fast. So across my stores I use Path C: one custom app per store, its Admin API token dropped into a local config, and Claude talks to whichever store I name, no switching. It also scripts cleanly for my daily checks. Path B (the CLI dev tools) is useful for inspecting the Admin GraphQL schema, but it is not how I run day-to-day store ops.

Path A: Claude Desktop connector (no code, ~5 minutes)

This is the path most operator clients pick, and it is the one Shopify and Anthropic both endorse for non-developers. Step by step:

1. Install Claude Desktop if you do not already have it. You need a Claude.ai Pro, Max, Team, or Enterprise subscription.
2. Open Claude Desktop. In the left sidebar, click Customize, then Connectors.
3. Click the + icon at the top of the Connectors panel. A directory of available connectors opens.
4. Find Shopify in the directory and click Connect.
5. Claude redirects you to your Shopify admin to authorize the connection. Review the data access level Shopify shows. You can decline any scope you do not want.
6. Approve. Shopify returns you to Claude. The Shopify connector now appears in your sidebar with 25 available tools (search products, get shop info, list orders, list customers, update product, and more).

That is the entire setup. No token to paste, no config file to edit, no CLI command to run. Test it by asking Claude: “Using Shopify, show me my 5 most recent orders.”

Reference: Shopify’s official guide + Claude Shopify connector page.

Path B: Shopify AI Toolkit MCP via Claude Code (~15 minutes)

If you live in a terminal and write prompts as part of your workflow, this path gives you scripted control. The Shopify AI Toolkit is an official Shopify package, open-sourced on April 9, 2026 under MIT license at github.com/Shopify/Shopify-AI-Toolkit.

Prerequisites:

• Claude Code installed (install guide). Quick check: claude --version should print a number.
• Node.js 18 or higher (node --version to confirm)
• A Shopify Partner account, free at partners.shopify.com

Install the MCP server with one command:

claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest

Then authenticate to your store using the Shopify CLI:

shopify auth login

Restart Claude Code. The connector exposes 7 tools (search docs, validate GraphQL queries, execute store ops). Verify with: “Using shopify-dev-mcp, show me the GraphQL schema for the Order type.”

If you have multiple stores, repeat the steps with separate alias names like shopify-store-a, shopify-store-b. Reference: Shopify AI Toolkit docs.

Path C: Custom app + Admin token (this is what I actually use)

This is the path I run across my stores, so I will be specific. You create a custom app, get its Admin API access token, and put that token in a local config that Claude reads. With the token, Claude talks straight to that store’s Admin API and you never touch the connector’s store picker.

If your store is older and already has a legacy custom app (token starts with shpat_), just reuse that token. It still works, it never expires, and you cannot recreate a legacy app, so do not delete it. You are done; skip the rest of this section.

If it is a new store, legacy custom apps are gone (see the January 2026 note above), so you build it in the Dev Dashboard. Shopify made this more work than the old copy-paste: there is no “reveal token” button anymore. You get a Client ID and Secret, then run a one-time OAuth exchange that returns a permanent offline access token. Here is the exact flow I use.

Step 1: Create the app

At dev.shopify.com, pick “Start from Dev Dashboard”, name the app, and click Create.

Step 2: Set the scopes and the redirect URL

In the app’s Access section, enter the Admin API scopes as a comma-separated list. My read-only set for store ops is read_products,read_orders,read_all_orders,read_inventory,read_locations,read_analytics,read_customers (add write_products only if you want Claude to make changes). Check Use legacy install flow, which is what enables the browser OAuth with a redirect. Then set Redirect URLs to the exact local address your script will listen on: http://localhost:3456/callback. If this does not match your script exactly, the browser step fails with no useful error. This is the single most common mistake. Release the version.

You can change scopes later by shipping a new version and re-approving. You do not have to rebuild the app.

Step 3: Copy the Client ID and Secret

Open the app’s Settings tab and copy the Client ID and Client secret. These are not the access token yet; they are what you exchange for one.

Step 4: Run a one-time OAuth script

This short script replaces the old copy-paste. It opens the browser, you approve once, and it exchanges the code for a permanent offline token. Python, standard library, nothing to install:

#!/usr/bin/env python3
"""
shopify_oauth_token.py - get a PERMANENT offline Admin API token for your OWN Shopify store.

One-time OAuth over localhost. Requires the custom app's Client ID + Client Secret
(Dev Dashboard -> your app -> Settings) and the redirect URL
http://localhost:3456/callback registered on the app (Access -> Redirect URLs).

Run:
  python shopify_oauth_token.py --shop your-store.myshopify.com --client-id XXX --client-secret YYY

The browser opens, you click Install/Approve once, and it prints an offline access token
(shpat_...) that DOES NOT expire. Paste that token into your .env.  Stdlib only, no pip installs.
"""
import argparse, http.server, secrets, urllib.parse, urllib.request, json, webbrowser, threading, sys

PORT = 3456
REDIRECT = f"http://localhost:{PORT}/callback"   # MUST match the Redirect URL registered on the app

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--shop", required=True, help="your-store.myshopify.com")
    ap.add_argument("--client-id", required=True)
    ap.add_argument("--client-secret", required=True)
    ap.add_argument("--scopes",
                    default="read_products,read_orders,read_all_orders,read_inventory,"
                            "read_locations,read_analytics,read_customers")
    a = ap.parse_args()
    shop = a.shop.replace("https://", "").replace("http://", "").strip("/")
    state = secrets.token_urlsafe(16)
    holder = {}

    # No grant_options[]=per-user  => OFFLINE access mode => permanent token.
    authorize = (f"https://{shop}/admin/oauth/authorize?client_id={a.client_id}"
                 f"&scope={urllib.parse.quote(a.scopes)}"
                 f"&redirect_uri={urllib.parse.quote(REDIRECT)}"
                 f"&state={state}")

    class H(http.server.BaseHTTPRequestHandler):
        def log_message(self, *_):
            pass
        def do_GET(self):
            q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
            if "code" not in q:
                self.send_response(400); self.end_headers(); return
            if q.get("state", [""])[0] != state:
                holder["err"] = "state mismatch (possible CSRF) - aborting"
                self.send_response(400); self.end_headers(); return
            holder["code"] = q["code"][0]
            self.send_response(200); self.send_header("Content-Type", "text/html"); self.end_headers()
            self.wfile.write(b"<h2>Auth OK - you can close this tab and return to the terminal.</h2>")
            threading.Thread(target=self.server.shutdown).start()

    srv = http.server.HTTPServer(("127.0.0.1", PORT), H)
    print(f"Opening the browser to authorize on {shop} ...")
    print(f"If it does not open, paste this URL into your browser:
{authorize}
")
    webbrowser.open(authorize)
    srv.serve_forever()  # blocks until the callback is received

    if "code" not in holder:
        print("No auth code received:", holder.get("err", "(cancelled)")); sys.exit(1)

    body = urllib.parse.urlencode({
        "client_id": a.client_id, "client_secret": a.client_secret, "code": holder["code"],
    }).encode()
    req = urllib.request.Request(f"https://{shop}/admin/oauth/access_token", data=body)
    resp = json.load(urllib.request.urlopen(req, timeout=30))

    token = resp.get("access_token", "")
    print("
=== AUTH SUCCESS ===")
    print(f"  store : {shop}")
    print(f"  scope : {resp.get('scope')}")
    print(f"  token : {token}")
    if "expires_in" in resp:
        print("  WARNING: this token expires - you requested an ONLINE token. Re-run for offline.")
    else:
        print("  offline token (no expiry) - paste it into your .env, e.g.  SHOPIFY_TOKEN_STOREA=" + (token[:12] + "..." if token else ""))

if __name__ == "__main__":
    main()

Run it with your store domain, Client ID, and Client Secret:

python shopify_oauth_token.py --shop your-store.myshopify.com --client-id XXX --client-secret YYY

Step 5: Approve, and you have your token

The browser opens Shopify’s install screen. Approve it.

The tab lands on a local success page, and the terminal prints your offline access token (shpat_...). It has no expiry. Paste it into your config or .env, and Claude can reach that store.

One warning that matters: take the offline token, not the online one. The online token (and the client-credentials token) expires in about 24 hours, which makes your config go stale every day. The script above requests offline by default, so the token you get is permanent.

Why I use this over the connector: with several stores, the connector makes you switch the active store constantly. With one token per store in my config, I just say “using store A, do X” and it goes. That is the difference that matters at multi-store scale.

Verify it works with one prompt

Open Claude (Desktop for Path A, Claude Code for Path B). Paste this prompt:

Using my Shopify store, list the 5 most recently created products. Show the title, price, and inventory quantity for each.

If the wiring is correct, Claude returns a clean table of 5 products from your live store. If you see “I do not have Shopify access” or an authorization error, jump to the “Errors” section below.

5 prompts I run on my stores every week

This is where the workflow pays off. These are not “show me a dashboard” prompts. They are ops decisions you would otherwise make in 4 browser tabs and a spreadsheet.

1. “Show me products with low stock and recent sales velocity”

Pull all products with current inventory below 10 units. For each, show the number of orders containing that product in the last 30 days. Sort by orders descending. I want to know what to reorder first.

Output: a ranked list of restock priorities, not just a low-stock report. This is the difference between data and decision.

2. “Audit collection pages with no description or no products”

List all collections that have either an empty body_html field or zero products assigned. Format as a table with the collection title and which problem applies.

I caught 12 broken collections on one store doing this in 30 seconds. Collections with no products are dead pages in search, and Google penalizes them over time.

3. “Find duplicate products by title fuzzy match”

Pull all active products. Group titles that are ≥80% similar by token overlap. Show me clusters of 2 or more.

This finds variants accidentally listed as separate products, a common mess on stores that ran imports from multiple sources. The Shopify admin UI does not show this. Claude can.

4. “Which orders had high refund value last month and what was the most common reason”

Pull orders from the last 30 days with refund amount above $50. Show order number, refund amount, refund reason if recorded. Then summarize the top 3 reasons by frequency.

This is a customer service signal you would otherwise dig out of Shopify’s refunds export plus a CSV scrub. Claude does it in one turn.

5. “Compare conversion rate of products with vs without descriptions over 200 words”

For each active product, calculate word count of body_html, then bucket as short (under 200 words) or long. Compare orders-per-1000-views (approximation: orders ÷ products of similar age × 1000) between the two buckets.

This is a directional analysis, not a perfect controlled test, but it surfaces the “do my long descriptions actually convert better” question with real numbers.

5 errors I hit so you can skip them

Error 1: Path A connector authorization screen never returns me to Claude

Cause: Browser blocked the popup or you signed into the wrong Shopify account. Fix: confirm the Shopify admin tab is your target store, retry the Connect button, allow popups for claude.ai. The redirect back to Claude Desktop happens automatically when authorization completes.

Error 2: Path B install command errors with “claude: command not found”

Cause: Claude Code is not installed or not on your PATH. Run which claude (macOS/Linux) or where claude (Windows). If empty, install from the official docs.

Error 3: Path B MCP server hangs on first run

Cause: npx -y is downloading the @shopify/dev-mcp package the first time. On a slow connection this can take 60-120 seconds. Wait it out. Subsequent runs are instant because the package is cached locally.

Error 4: Claude returns “I cannot access that data” even though the connector is active

Cause: You declined or never granted the scope that entity needs. Path A: revisit the connector authorization page in Claude Desktop and re-approve with broader access. Path B: rerun shopify auth login and confirm the Partner account has scope access to the target store.

Error 5: I get answers but the numbers feel off

Cause: Claude returned partial data because the query hit a pagination cap. Shopify GraphQL pages return 250 records at a time. For “every order this year” type questions, narrow by month or filter by status, then ask Claude to aggregate. Mention in your prompt: “paginate through all results before summarizing.”

Bonus: schedule 5 ops routines with Claude Code Routines

Once the connector is live, the highest-impact move is to stop running these prompts ad hoc and let Claude run them on a schedule. Anthropic shipped a feature called Routines on April 14, 2026 (currently in research preview) that does exactly this. It is included on Pro, Max, Team, and Enterprise plans.

What Routines are, briefly

A routine is a saved Claude Code configuration: a prompt, optionally one or more GitHub repositories, and the connectors you want it to use. Routines run on Anthropic-managed cloud infrastructure, so they keep running when your laptop is closed. Three trigger types are supported:

• Schedule, hourly, daily, weekdays, weekly, or a one-off at a specific timestamp. Minimum interval is 1 hour. Custom cron via /schedule update.
• API, a per-routine HTTPS endpoint you can POST to with a bearer token. Wire it to your monitoring tool, deploy pipeline, or any system that emits a webhook.
• GitHub event, pull request opened/merged/labeled, release published, with filters by branch, author, labels, etc.

Create routines from claude.ai/code/routines, from the Routines tab in Claude Desktop’s sidebar, or with /schedule in the CLI. All three surfaces sync to the same cloud account. Source: Anthropic Routines docs.

Important: the connectors a routine can use are the ones connected on your claude.ai account (claude.ai/customize/connectors), not local MCP servers added via claude mcp add on your machine. If you set up Shopify via Path A, your routines can already see it. If you set up via Path B only, you also need to add the Shopify connector to your claude.ai account for routines to reach it.

Below are 5 routines I run for store operators. Times are local. Drop them into the New routine form, attach the Shopify connector, set the schedule, and forget about them.

Routine 1: Daily sales pulse, schedule “daily at 8 AM”

Using my Shopify store, compare yesterday’s gross sales, order count, and AOV against the 7-day rolling average. Flag any metric that moved more than 15% in either direction. Reply with only the 3 most material deltas in plain text. If no metric moved more than 15%, reply with one sentence confirming the day was normal.

Why daily: catches a tracking break, a viral SKU, or a Friday discount surprise before it compounds across a week.

Routine 2: Out-of-stock watchlist, schedule “hourly” (or “every 4 hours” via custom cron)

Using my Shopify store, list products currently at zero inventory that had at least 5 unit sales in the last 14 days. Group by vendor. Skip products tagged ‘discontinued’. Reply with the list grouped, or one sentence if nothing matches.

Why intraday: a bestseller selling out at 2 PM and not getting flagged until next morning is a full afternoon of lost revenue. If hourly is too noisy for your store, raise the interval via /schedule update.

Routine 3: Slow-mover inventory, schedule “weekly on Monday”

Using my Shopify store, show products with inventory greater than 50 units and zero sales in the last 30 days. Sort by inventory value descending. Reply with a table I can act on for discount, bundle, or kill decisions.

Why weekly: slow movers eat cash. A weekly review keeps the catalog honest without becoming noise.

Routine 4: Open ticket aging, schedule “daily at 5 PM”

Using my Shopify store, pull orders from the last 30 days that have notes or tags indicating an open customer issue. Show only those unresolved for more than 48 hours, with customer email and order value. Sort by order value descending.

Why daily: a $400 customer waiting 3 days for a reply is a refund risk and a 1-star review risk. Prioritize by value, not by inbox order.

Routine 5: Refund anomaly check, schedule “daily at 9 AM”

Using my Shopify store, calculate yesterday’s refund rate (refund count ÷ order count) and compare to the 30-day average. If yesterday exceeds the average by more than 2x, list the refunded orders and group by refund reason. Otherwise, reply with one sentence confirming the rate is normal.

Why daily: refund spikes mean a product defect, a shipping problem, or a fraud wave. Catching it on day 1 saves a 7-day cleanup.

You do not need all five. Start with Routine 1 (sales pulse) since it is the broadest signal. Add the others one at a time as you trust the prompts. Routines runs are subject to a daily run cap on your plan; one-off runs do not count against the cap. See claude.ai/settings/usage for your current allowance.

If you do not have Routines (Free plan, or admin-disabled in your org), you can still pull these prompts manually each morning, or wire them into a local cron job that pipes into Claude Code. The prompts themselves work in any setup.

What you can’t do (honest limits)

I want to be straight about this so you do not buy into AI hype:

• This does not write code into your theme. Claude can read Liquid templates if you give it read_themes scope, but pushing template changes through MCP is risky and I do not recommend it. Use the regular theme editor.
• This is not a dashboard. You ask, you get an answer in chat. Beautiful charts are not the output. The output is a decision, made faster.
• Large queries cost real tokens. Asking for “every order in 2024” pulls 12 months of data into Claude’s context. That is expensive and slow. Batch by month, narrow by filter, paginate.
• Multi-store takes a one-time setup per store. Each store needs its own token or connector entry. Once that is done (Path C makes it painless), you pick a store with a phrase in your prompt, not by clicking around. There is no magic “all my stores at once” button; you name the store you mean.
• Read-only is safer. Write scopes (write_products, write_orders) are powerful and irreversible. A wrong prompt can update 200 products instantly. Keep read-only until you trust your prompts.

Who this is for, who it is not for

You will get a lot out of this if:

• You run a Shopify store and already use Claude (or ChatGPT) for ops thinking
• You spend more than 2 hours a week pulling reports from Shopify admin
• You want to start small (read-only queries) before scaling to automation
• You like clear answers in plain English more than building dashboards

You should skip this if:

• You have under 100 orders/month (the manual reports are still faster)
• You are looking for a no-code automation platform (try Zapier or Make instead)
• You need a polished visual dashboard for your team (try Shopify Analytics or a third-party BI tool)
• You expect AI to make ops decisions for you without review (it surfaces signals; you still call the shots)

FAQ

Which of the three paths should I pick?

One store, mostly chatting with your data: Path A (the connector). Multiple stores, or you want to script daily checks: Path C (custom app + Admin token), which is what I run because it skips the connector’s store-switching. Path B (the CLI dev tools) is mainly for inspecting the Admin GraphQL schema. Single-store operators I onboard usually start on Path A; multi-store operators are better off on Path C from the start.

Is this safe for my store?

Both Path A and Path B grant scopes you approve. The worst Claude can do is what those scopes allow. Approve read-only first, watch what Claude does for a week, then add write scopes when you trust your prompts. For Path A, you can revoke the connection any time inside Claude Desktop’s connector settings or in Shopify admin under installed apps. For Path B, removing the MCP entry from your config kills access instantly.

How much does this cost to run?

Path A uses your Claude.ai subscription (Pro, Max, Team, or Enterprise) and counts against your monthly message limit. Path B uses Claude Code billed per token by Anthropic. A typical operator query (one of the 5 above) uses 5-15k tokens including Claude’s response. At current pricing that is fractions of a cent per query. I spend under $20 per month on Claude API across my stores.

Does this work with multiple stores?

Yes, and it is the main reason I use Path C. Path A: authorize each store in the connector picker and switch in the sidebar, which is fine for one or two but tedious past that. Path C: give each store its own custom-app token in your config, then say “using store A, do X” in the prompt, no switching. Running several stores is exactly what pushed me off the connector and onto tokens.

Can I use this with Shopify Plus or just standard plans?

Standard, Advanced, and Plus all work. Custom apps are available on every paid plan. The Admin GraphQL API endpoints behave the same across plan tiers.

What about writing back to Shopify (update products, tag orders)?

You can, after you approve write access for the connector. Path A: on the connector authorization screen, approve the data access tier that includes the write tools you need. Path B: ensure the Partner account has the write scope on the target store. Then prompts like “update product X tag to include ‘restocked'” work. I do this only for batch tag updates and inventory adjustments, and only after testing on a single product first. Mass-update with care.

Routines is labeled “research preview”, is it safe to rely on?

Anthropic shipped Routines on April 14, 2026 in research preview. Behavior, limits, and the API surface may change. For ops routines that fire daily and only report data back to you, the risk is low: if a routine breaks, you notice the next morning and re-create it. For routines that write back to Shopify or take destructive action, I would wait for general availability or pair every write with a manual review checkpoint. Source: Anthropic Routines documentation.

Is this the same as Shopify Sidekick?

No. Shopify Sidekick is Shopify’s own AI assistant embedded in the admin. It is good for in-admin chat but locked to Shopify’s product. The MCP route gives you Claude (or any MCP-capable AI) with full Admin API reach, and you control the prompts, the scopes, and the data flow. They serve different use cases.

Related, the same operator-audit approach on the paid side: the 4 money leaks I found auditing my own Google Ads.

A note on bias before we start. I bought into this toolkit because the blog audit problem at ND Nail Supply was eating my weekends, and the kit looked complete on paper. I have now used it on real production data. This review is favorable, but it is favorable because the tool earned that grade against the actual checks below, not because of any relationship with the author. Anything I think is missing or unfinished is in the gaps section halfway down.

If you operate a paid acquisition stack of any meaningful size, the branded search campaign is the single channel most likely to be misread by your dashboard. This is the post I send to founders and operators before our intro call so we can skip the basics and get to the actual diagnostic. Each mistake below comes from a real audit pattern across my own three brands plus client engagements across Shopify wholesale, WooCommerce shops, WordPress content sites, and local businesses.