Can Claude Code Build Shopify Apps? (2026)

The Short Answer: Yes, With Important Caveats

Can Claude Code build Shopify apps? Yes — it can scaffold a working Remix-based Shopify app in under an hour, wire up OAuth, generate webhooks, and produce UI extensions that run against a development store. What it cannot do on its own is ship a production-ready, App Store-approved, billing-compliant product without meaningful human oversight.

The gap between "it works on my dev store" and "it passed review and has 50 paying merchants" is where the nuance lives. If you understand that gap, Claude Code becomes one of the highest-leverage tools in a Shopify developer's workflow. If you ignore it, you end up with a demo that can't charge money and a rejection email from the App Review team.

This guide is the honest breakdown: what Claude Code builds well, where it still struggles, a realistic time-to-ship, a cost comparison against a traditional agency build, and a starter prompt you can paste today. For the bigger picture on using this tool across your whole dev workflow, pair this with our complete guide to Claude Code for Shopify development.

What Changed in April 2026

Shopify released its official Shopify AI Toolkit on April 9, 2026 — a free, open-source MCP (Model Context Protocol) server that plugs directly into Claude Code. It exposes seven tools including learn_shopify_api, search_docs_chunks, introspect_graphql_schema, and store_execute, which together let the AI query current API schemas, validate queries before you run them, and execute commands against a development store without leaving your editor. That release is the single biggest reason the answer flipped from "kind of" to a confident "yes, with caveats" in 2026.

What Claude Code Builds Well

Claude Code shines when the work is well-documented, convention-heavy, and bounded by a clear schema. The Shopify app stack is exactly that — Remix conventions, GraphQL Admin API, Polaris components, and App Bridge are all publicly documented and semantically structured.

Here's where it consistently produces production-quality output:

• Remix app scaffolding — the shopify-app-template-remix starter combined with Claude Code produces a running app with OAuth, session storage, and App Bridge in 10-15 minutes
• GraphQL Admin API queries and mutations — especially with the AI Toolkit's validate_graphql_codeblocks tool catching version drift before you run the code
• Webhook handlers — APP_UNINSTALLED, PRODUCTS_UPDATE, ORDERS_PAID, and the mandatory compliance webhooks (customers/data_request, customers/redact, shop/redact)
• UI extensions and checkout extensions — Claude handles the extension target syntax, configuration TOML files, and Polaris components cleanly
• Theme app extensions — Liquid blocks, schema definitions, and the {% schema %} JSON payloads
• Internal admin UI pages — Polaris components render with correct props, and Claude understands the App Bridge navigation patterns
• Dev-only endpoints and seed scripts — exactly the kind of one-off glue code that drains senior dev time

A developer documented building a complete Shopify review app called ReviewMate entirely with Claude Code, and the AI handled HMAC verification, XSS protection, and other security patterns without explicit prompting — the app is now serving real merchants in production per the Medium build log. That's representative, not exceptional.

The AI Toolkit Changes the Math

Before the AI Toolkit, you spent half your prompt budget pasting docs into context or correcting outdated syntax. Now Claude pulls the current API version and schema directly. Shopify's own AI Toolkit documentation explains the seven-tool surface, and the practical effect is that Claude stops inventing GraphQL fields. That one change — deterministic schema access — makes the scaffolding stage feel closer to a senior dev pairing than a chatbot guessing.

Where Claude Code Still Struggles

The model is a strong mid-level engineer. It is not a Shopify Partner Program lawyer, a QA team, or a billing accountant. Four areas remain genuinely hard, and you will either handle them yourself or hire help.

App Store Submission Packaging

Shopify's review team tests installation flow, Lighthouse impact on real storefronts, GDPR webhook responses, demo credentials, screencasts, and the app listing copy itself. Per Shopify's App Store requirements checklist, you need a 1200x1200 icon, video walkthrough in English, working test credentials, and a production app URL with valid HTTPS — none of which Claude Code produces. Typical review cycle is 5-10 business days, and per eSEOspace's Shopify App Store approval walkthrough, partners get temporarily suspended from submitting if they fail to address feedback after two exchanges. The AI will happily claim the app is "ready for submission" when it isn't.

Billing API Flows Under Real Tax Conditions

The Remix authenticate.admin(request) call exposes billing.require(), billing.request(), and billing.cancel() utilities — Magecomp's Remix billing-with-trial tutorial walks through the full config. Claude scaffolds these correctly. What it struggles with: usage-based charges that clamp at the cappedAmount, multi-plan upgrades with prorated credits, and the trial-day edge cases where merchants uninstall mid-trial and reinstall later. The Billing API also only works for publicly distributed apps — custom apps have to integrate Shopify Payments or an external processor, and Claude sometimes confuses the two contexts.

Compliance, Privacy, and Protected Data

Customer data APIs require an approved use case. GDPR webhooks must actually delete data, not log a TODO. App security review can catch a missing verifyRequest wrapper or a cookie with SameSite=None but no Secure flag. These are binary pass/fail gates, and Claude is not incentivized to flag them unless you ask.

Multi-Session, Long-Running Logic

Inventory sync daemons, bulk operation polling, and workflows that span multiple webhook deliveries need careful state management and idempotency keys. Claude produces a happy-path version quickly, then you spend a week hardening it against retries, duplicate deliveries, and Shopify's 2-second webhook timeout.

Setup: Getting Claude Code Ready for Shopify App Dev

You need three things wired together: Claude Code itself, the Shopify CLI, and the Shopify AI Toolkit MCP server.

1. Install Shopify CLI — npm install -g @shopify/cli @shopify/theme, authenticate with shopify auth login
2. Create the app — shopify app init --template=https://github.com/Shopify/shopify-app-template-remix --name=my-app
3. Install the AI Toolkit MCP server — claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest
4. Add a `CLAUDE.md` to your app root that declares the API version from shopify.app.toml, your Polaris version, and any custom conventions
5. Turn on `shopify app dev` in a separate terminal so Claude can see HMR errors and tunnel logs

The critical detail many devs miss: always specify the target API version in your prompt or in CLAUDE.md. The Fudge.ai Shopify AI Toolkit walkthrough notes that Claude will sometimes generate code against a newer API version than your app is configured for — pinning the version in context prevents silent version drift.

Directory Hygiene That Keeps Claude Honest

Structure matters. Keep Remix routes in app/routes/, keep Polaris UI in app/components/, and put all GraphQL queries in a dedicated app/lib/queries.ts. When Claude knows where things belong, it stops scattering duplicates. For more on the underlying tool, our Claude Code Shopify CLI integration guide covers the command surface in depth.

Example: A Minimal Custom App in One Session

Here's the scope I recommend for your first real run: a custom app that listens to ORDERS_PAID webhooks, writes a row to a Postgres table, and renders a dashboard inside the Shopify admin showing today's revenue.

Paste this prompt into Claude Code from inside a fresh shopify app init directory:

You have access to the Shopify AI Toolkit MCP server.

Build a minimal custom app with these requirements:

1. Handle the ORDERS_PAID webhook. Verify HMAC. Idempotent by order ID.
2. Persist { orderId, shop, totalPrice, currency, createdAt } to a
   Postgres table called `order_events`. Create the schema if it doesn't
   exist. Use Prisma.
3. Build an admin route at /app/dashboard that queries order_events for
   the authenticated shop and renders a Polaris Card with today's revenue,
   order count, and average order value.
4. Use API version 2026-01. Use the Shopify App Remix v3 patterns
   (authenticate.admin, authenticate.webhook).
5. Register the webhook in shopify.app.toml, not in code.
6. Add the three mandatory compliance webhooks returning 200 with a
   stub implementation I'll fill in later.

Before writing code:
- Use introspect_graphql_schema to confirm the Order fields I need.
- Use search_docs_chunks to confirm the current webhook verification
  pattern for Remix.

Then scaffold it, explain each file, and list what I still need to do.

What you get back in ~20 minutes: a running app, a dashboard that reads real orders from your dev store, webhook handlers that survive a shopify app deploy, and a clear TODO list for the parts you still need to harden. For a deeper walkthrough of the full app creation process end-to-end, see our guide on how to create a Shopify app from scratch.

Subagents: Where Claude Code Really Earns Its Keep

Single-prompt scaffolding is useful. Subagents — specialized sub-instances of Claude with narrow, repeatable jobs — are where the workflow compounds. Shopify app development has natural subagent boundaries because the platform is already segmented by concern.

Here are five subagents worth building into .claude/agents/ for any serious Shopify app project:

The VoltAgent awesome-claude-code-subagents collection has 100+ generic subagents you can adapt, and Shopify-specific subagent skills like shopify-expert are already published. You don't have to invent these from scratch.

Why Subagents Beat Monolithic Prompts

A single "build me a Shopify app" prompt runs hot — you burn context, the model forgets the early constraints, and by the end it's guessing. A subagent that only reviews GraphQL queries can load the schema once and stay sharp. The cognitive load stays with the tool, not you. If you're exploring the subagent model more broadly, our ChatGPT vs Claude for Shopify merchants comparison covers the trade-offs between the two platforms.

Realistic Scope: Hours vs Weeks

One of the most common misreads of AI coding tools is confusing "the MVP works" with "the product ships." Here's what my team sees on real Shopify app builds with Claude Code driving.

Totals: an MVP in a solo weekend, a production-ready public app in 3-5 weeks including review. The Stormy AI guide to scaling Shopify app GTM with Claude Code tracks similar numbers across several 2026 launches.

Custom Apps vs Public Apps

The scope math is dramatically different for a single-store custom app. You skip the App Store review, skip most of the compliance webhooks, and often skip the Billing API entirely. Custom apps for a single merchant using Claude Code regularly ship in 2-4 days of focused work. See our deep dive on Shopify custom app development and the 2026 changes for the latest rules.

Cost Comparison: Claude Code vs Agency Build

Here's where the economics get interesting. The pricing benchmarks below come from AppMaker's 2026 cost analysis for Shopify apps and Folio3's 2026 app development cost guide.

Claude Code Max at $200/month is less than 1% of a typical agency quote. Even accounting for the specialist hours you still buy (a Shopify-savvy reviewer for 5-10 hours before submission, maybe a designer for the listing assets), the all-in cost for a public app on the AI-assisted path lands around $3K-$8K versus $50K+ for the traditional route.

The Hidden Cost Nobody Talks About

Agencies bundle coordination, QA, documentation, and project management. If you're going solo with Claude Code, those responsibilities land on you. Block 15-20% of your time for the meta-work — status tracking, version pinning, regression testing, credential management — that agencies quietly absorb. Skipping this is how the "Claude built my app in a weekend" stories turn into "why is production broken at 2am" stories two months later.

Submission Reality Check

Passing App Store review is the hardest part, and Claude Code helps least here. The review team is humans testing your app like merchants. They install it on a fresh store, poke it, measure Lighthouse impact before and after, try to uninstall and reinstall, and read every screen of copy you wrote.

Non-negotiable items Claude will not catch for you:

1. App listing copy — plain English, no feature-dumping, a clear value prop in the first sentence
2. Screencast demonstrating the full user journey — install → configure → use the core feature → uninstall
3. Working demo credentials with full feature access — Shopify rejects submissions with restricted test accounts
4. Lighthouse impact — your app should not regress the storefront score when installed; measure it yourself
5. Emergency developer contact — a real human email in your Partner Dashboard for Shopify to reach you
6. Legal pages — Privacy Policy, Terms of Service, refund terms — live URLs, not drafts
7. Compliance webhooks returning 200 — and actually honoring the request, not just logging it

The Gadget.dev guide to passing Shopify App Store review on the first try is the single best external resource for this stage. Read it before you submit.

Use Claude Code to Pre-Flight the Submission

Spin up the review-pre-flight subagent mentioned earlier and have it run against the Codersy breakdown of Shopify App Store guidelines item-by-item. It won't replace a human QA pass, but it catches 80% of the common rejection triggers before you waste a review cycle.

Common Mistakes to Avoid

These are the patterns that show up over and over when merchants try to build apps with Claude Code and hit a wall.

• Not pinning the API version — Claude defaults to whatever it saw last; your shopify.app.toml and every prompt should both declare the version explicitly
• Skipping the AI Toolkit MCP server — you're giving Claude stale docs and hoping; the MCP server makes the whole workflow deterministic, install it on day one
• Running `shopify app deploy` before testing webhooks locally — test in the dev tunnel first, because a bad webhook registration in production is annoying to roll back
• Treating Billing API like it's optional for public apps — merchants who bypass the Billing API get flagged in review and risk losing their partner account
• Ignoring the 2-second webhook timeout — if your handler does a slow operation, queue the work and return 200 immediately; Claude sometimes writes synchronous handlers that miss this
• Shipping the default template UI — the Remix starter has placeholder text that will absolutely get flagged in review; change everything before submission
• Using `any` or `@ts-ignore` to get the build green — Claude will suggest these when it's stuck, accept them and you're shipping a real bug under a silenced error
• Skipping App Bridge for deep linking — direct URL manipulation breaks embedded app navigation, and merchants will file support tickets you don't want
• Forgetting to test the uninstall flow — reviewers always uninstall, and your APP_UNINSTALLED webhook has to actually clean up session storage, not just log

Frequently Asked Questions

Can Claude Code build a Shopify custom app (not public)? Yes, and this is where it's strongest. Custom apps skip App Store review, most compliance webhooks, and the Billing API. Expect 2-4 days of focused work for a substantial custom app.

Does Claude Code work with Shopify theme extensions too? Yes. Liquid blocks, {% schema %} definitions, and the shopify.theme.toml config file are all well within scope. See our Shopify custom sections Liquid tutorial for patterns you can hand to Claude.

What about mobile apps? Shopify's Remix stack is web-based. For native iOS/Android apps, you're better off with a Shopify-specific mobile app builder or a traditional agency — Claude Code helps less there.

Is Claude Code better than Cursor for Shopify work? Both now support the Shopify AI Toolkit. Claude Code has better subagent support and longer context; Cursor has tighter IDE integration. Pick the one that fits your existing editor habits — the Shopify-specific tooling is identical.

Will using Claude Code get my app rejected? No. Shopify reviews the output, not the process. Rejections come from missing compliance webhooks, bad listing copy, or Lighthouse regressions — not from AI authorship.

Final Take

Claude Code in April 2026, paired with the Shopify AI Toolkit, is the best tool a solo Shopify app developer has ever had. It collapses scaffolding work from days to hours, writes production-quality webhook handlers and Polaris UI, and enables a realistic solo path to a public App Store listing in under 6 weeks.

It does not replace the human judgment that gates App Store approval, nor the accounting rigor that Billing API edge cases demand, nor the ongoing ops work that any production SaaS requires. Treat it as a senior engineer teammate who's fast and literal — not as an autopilot.

If you're ready to go deeper, explore our full Shopify development resources and the AI and emerging tech category for more on how AI is reshaping the merchant stack. Join the Talk Shop community if you want to compare notes with other builders shipping Shopify apps this month — half the thread is people debugging their first ORDERS_PAID handler and the other half are celebrating their App Store approval.

What's the one feature you'd scaffold with Claude Code first — a custom admin dashboard, a theme extension, or a full public app?

About Talk Shop

The Talk Shop team — insights from our community of Shopify developers, merchants, and experts.