菜单
Define and populate agentic-commerce metafields (material, attributes, key features, specs, sizing) so AI agents can filter and match products to specific shopper requirements.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/40RTY-ai/shopify-admin-skills --skill shopify-admin-agentic-metafields-setup命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Master skill collection for Shopify store operators. Provides access to all merchandising, marketing, support, and operations capabilities.
Edit the theme's robots.txt.liquid to explicitly allow AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, OAI-SearchBot, Amazonbot) so AI assistants are permitted to read the catalog.
Rewrite thin product descriptions into structured, fact-rich copy (materials, fit, use-cases, the words shoppers actually type) so AI agents have something concrete to quote and match.
基于 SOC 职业分类
正在显示 SKILL.md
| name | shopify-admin-agentic-metafields-setup |
| role | agentic |
| description | Define and populate agentic-commerce metafields (material, attributes, key features, specs, sizing) so AI agents can filter and match products to specific shopper requirements. |
| toolkit | shopify-admin, shopify-admin-execution |
| api_version | 2025-01 |
| graphql_operations | ["metafieldDefinitions:query","metafieldDefinitionCreate:mutation","products:query","metafieldsSet:mutation"] |
| status | stable |
| compatibility | Claude Code, Cursor, Codex, Gemini CLI |
| audit_signals | ["listing-metafields","variant-metadata","sizing-specs-structured"] |
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.
shopify auth login --store <domain>)read_products, write_products, read_metaobject_definitions, write_metaobject_definitions (for definitions)All skills accept these universal parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| store | string | yes | — | Store domain (e.g., mystore.myshopify.com) |
| format | string | no | human | Output format: human (default) or json |
| dry_run | bool | no | false | Preview mutations without executing |
Skill-specific parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| namespace | string | no | agentic | Metafield namespace to create/populate under |
| keys | string | no | material,features,care,fit,specs | Comma list of metafield keys to ensure exist |
| collection_id | string | no | — | Limit population to a collection GID |
| tag | string | no | — | Limit population to a product tag |
| populate_from | string | no | tags,options,description | Sources to infer values from (no fabrication beyond these) |
⚠️ 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. Rundry_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.
OPERATION: metafieldDefinitions — query
Inputs: ownerType: PRODUCT, namespace: <namespace>
Expected output: Which target keys already have definitions (skip those).
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).
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.
OPERATION: metafieldsSet — mutation
Inputs: batches of { ownerId, namespace, key, value, type } for confidently-inferred, currently-empty values.
Expected output: Set metafields; collect userErrors.
# 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 }
}
}
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
}
}
human: definitions created + a CSV of populated values (product, key, value, source). json: { definitions_created, metafields_set, products_touched, errors, output_file }.
| Error | Cause | Recovery |
|---|---|---|
THROTTLED | API rate limit | Wait 2s, retry up to 3 times |
TAKEN on definition | Key already defined elsewhere | Reuse the existing definition, continue to population |
userErrors on set | Type mismatch (e.g. list vs single) | Coerce value to the definition's type, retry once, else skip |
agentic) and the key set tight — agents and storefront filters both benefit from consistency.list.single_line_text_field for multi-value attributes (features, materials) so filters work as OR-sets.shopify-admin-agentic-description-enrichment so the prose and the structured data agree.