Shopify Admin Agentic Product Jsonld Backfill

Purpose

AI shopping agents read a product's structured data (the fields Shopify themes emit as schema.org/Product JSON-LD) to confirm price, availability, and identity. Missing barcodes (GTIN), SKUs, vendor, or product type leave the listing ambiguous — so the agent skips it or recommends a competitor whose data is complete. This skill finds products/variants with those gaps and backfills them: vendor and product type at the product level, barcode/SKU at the variant level. Fixes the agentiq.report findings product-schema-jsonld, gtin-sku-pdp, and variant-metadata.

Prerequisites

• Authenticated Shopify CLI session (shopify auth login --store <domain>)
• Required API scopes: read_products, write_products

Parameters

All skills accept these universal parameters:

Skill-specific parameters:

Safety

⚠️ Step 3 (productUpdate) and Step 4 (productVariantsBulkUpdate) write live product/variant data. Barcodes and SKUs are matched from your barcodes_csv; a wrong mapping mislabels a product's identity to every agent. Always run dry_run: true first and verify the change set CSV. This skill never overwrites a field that already has a value — it only fills blanks.

Workflow Steps

1. OPERATION: products — query Inputs: first: 250, optional query: "tag:'<tag>'" or collection filter; fields vendor, productType, variants{ id sku barcode }; paginate until hasNextPage: false. Expected output: Products/variants with missing target fields.

2. COMPUTE (no API): build the change set — only blank fields, joined to barcodes_csv by SKU for barcodes. Emit the preview CSV.

3. OPERATION: productUpdate — mutation Inputs: per product { id, vendor?, productType? } (only where blank and a value is supplied). Expected output: Updated product; collect userErrors.

4. OPERATION: productVariantsBulkUpdate — mutation Inputs: per product productId + variants: [{ id, barcode?, inventoryItem: { sku? } }] for blank variant fields. Expected output: Updated variants; collect userErrors across batches.

GraphQL Operations

graphqlCopy code
# products:query — validated against api_version 2025-01
query BackfillProducts($first: Int!, $after: String, $query: String) {
  products(first: $first, after: $after, query: $query) {
    edges {
      node {
        id
        title
        vendor
        productType
        variants(first: 100) {
          edges { node { id sku barcode } }
        }
      }
    }
    pageInfo { hasNextPage endCursor }
  }
}

graphqlCopy code
# productUpdate:mutation — validated against api_version 2025-01
mutation BackfillProductFields($input: ProductInput!) {
  productUpdate(input: $input) {
    product { id vendor productType }
    userErrors { field message }
  }
}

graphqlCopy code
# productVariantsBulkUpdate:mutation — validated against api_version 2025-01
mutation BackfillVariantFields($productId: ID!, $variants: [ProductVariantsBulkInput!]!) {
  productVariantsBulkUpdate(productId: $productId, variants: $variants) {
    productVariants { id sku barcode }
    userErrors { field message }
  }
}

Session Tracking

Claude MUST emit the following output at each stage. This is mandatory.

On start, emit:

Copy code
╔══════════════════════════════════════════════╗
║  SKILL: <skill name>                         ║
║  Store: <store domain>                       ║
║  Started: <YYYY-MM-DD HH:MM UTC>             ║
╚══════════════════════════════════════════════╝

After each step, emit:

Copy code
[N/TOTAL] <QUERY|MUTATION>  <OperationName>
          → Params: <brief summary of key inputs>
          → Result: <count or outcome>

If dry_run: true, prefix every mutation step with [DRY RUN] and do not execute it.

On completion, emit:

For format: human (default):

Copy code
══════════════════════════════════════════════
OUTCOME SUMMARY
  <Metric label>:   <value>
  Errors:           0
  Output:           <filename or "none">
══════════════════════════════════════════════

For format: json, emit:

jsonCopy code
{
  "skill": "<skill-slug>",
  "store": "<domain>",
  "started_at": "<ISO8601>",
  "completed_at": "<ISO8601>",
  "dry_run": false,
  "steps": [
    {
      "step": 1,
      "operation": "<OperationName>",
      "type": "query",
      "params_summary": "<string>",
      "result_summary": "<string>",
      "skipped": false
    }
  ],
  "outcome": {
    "metric_key": 0,
    "errors": 0,
    "output_file": null
  }
}

Output Format

human: counts of products/variants updated per field + a CSV of every change (product, variant, field, old, new). json: { products_updated, variants_updated, by_field{...}, errors, output_file }.

Error Handling

Best Practices

• Run shopify-admin-agentic-readiness-audit first to size the gap, then dry_run: true here to review the exact change set.
• Barcodes are GTIN/UPC/EAN — get them from your supplier, never invent them. A wrong GTIN is worse than a blank one.
• This skill only fills blanks; to correct existing-but-wrong values use shopify-admin-bulk-price-adjustment-style targeted edits instead.
• Pair with shopify-admin-agentic-metafields-setup — barcodes power JSON-LD identity, metafields power agent filtering; you usually want both.