메뉴
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에서 현재 제공할 수 있는 파일을 다운로드하세요.
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.SOC 직업 분류 기준
