Shopify Admin Agentic Metafields Setup

Purpose

AI agents answer constrained queries — "squat-proof leggings under $60", "eucalyptus slip-ons", "machine-washable wool" — by filtering on structured attributes. If those attributes live only in prose (or nowhere), the agent can't filter and your products drop out of the result set. This skill establishes a small, standard set of agentic metafield definitions (material, key features, care, fit, specs) and populates them across the catalog from existing product signals, so agents can match products to requirements. Fixes listing-metafields, variant-metadata, and sizing-specs-structured.

Prerequisites

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

Parameters

All skills accept these universal parameters:

Skill-specific parameters:

Safety

⚠️ Step 2 (metafieldDefinitionCreate) and Step 4 (metafieldsSet) write store schema + product data. Definitions are cheap to add but clutter the admin if mis-namespaced; values written from inference can be wrong. Run dry_run: true, review the proposed definitions and the value preview, and only populate values inferred with high confidence — leave the rest blank for human fill.

Workflow Steps

1. OPERATION: metafieldDefinitions — query Inputs: ownerType: PRODUCT, namespace: <namespace> Expected output: Which target keys already have definitions (skip those).

2. OPERATION: metafieldDefinitionCreate — mutation Inputs: one per missing key: { namespace, key, name, ownerType: PRODUCT, type: "single_line_text_field" | "list.single_line_text_field" } Expected output: Created definitions; collect userErrors (e.g. already-taken).

3. OPERATION: products — query Inputs: first: 250, optional filter; fields tags, options, descriptionHtml, existing metafields(namespace); paginate. Expected output: Products + the signals to infer attribute values from.

4. OPERATION: metafieldsSet — mutation Inputs: batches of { ownerId, namespace, key, value, type } for confidently-inferred, currently-empty values. Expected output: Set metafields; collect userErrors.

GraphQL Operations

# metafieldDefinitions:query — validated against api_version 2025-01
query AgenticMetafieldDefs($namespace: String!) {
  metafieldDefinitions(first: 50, ownerType: PRODUCT, namespace: $namespace) {
    edges { node { id namespace key name type { name } } }
  }
}

# metafieldDefinitionCreate:mutation — validated against api_version 2025-01
mutation AgenticMetafieldDefCreate($definition: MetafieldDefinitionInput!) {
  metafieldDefinitionCreate(definition: $definition) {
    createdDefinition { id namespace key }
    userErrors { field message code }
  }
}

# products:query — validated against api_version 2025-01
query AgenticMetafieldProducts($first: Int!, $after: String, $query: String, $namespace: String!) {
  products(first: $first, after: $after, query: $query) {
    edges {
      node {
        id
        title
        tags
        options { name values }
        descriptionHtml
        metafields(first: 20, namespace: $namespace) {
          edges { node { key value } }
        }
      }
    }
    pageInfo { hasNextPage endCursor }
  }
}

# metafieldsSet:mutation — validated against api_version 2025-01
mutation AgenticMetafieldsSet($metafields: [MetafieldsSetInput!]!) {
  metafieldsSet(metafields: $metafields) {
    metafields { id namespace key }
    userErrors { field message code }
  }
}

Session Tracking

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

On start, emit:

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

After each step, emit:

[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):

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

For format: json, emit:

{
  "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: definitions created + a CSV of populated values (product, key, value, source). json: { definitions_created, metafields_set, products_touched, errors, output_file }.

Error Handling

Best Practices

• Keep the namespace small and standard (agentic) and the key set tight — agents and storefront filters both benefit from consistency.
• Only write values you can infer with high confidence from real signals; a wrong "material: leather" misleads every agent. Leave low-confidence fields blank.
• Use list.single_line_text_field for multi-value attributes (features, materials) so filters work as OR-sets.
• Follow with shopify-admin-agentic-description-enrichment so the prose and the structured data agree.