"The AI just builds it." It is the line of the year, and merchants are right to raise it. Anyone can watch a tool spin up a clean landing page from a screenshot in a couple of minutes.
Here's the honest answer: that is true about the landing page, and it stops being true the moment you point the same tool at a Shopify product page. Not a little wrong. Wrong in a way that costs a week and a chunk of trust to unwind. The gap between those two outcomes isn't about the AI being good or bad. It's architectural, and understanding it is how you decide what to hand a machine and what to hand a person.
AI coding agents are genuinely excellent at traditional, self-contained layouts: marketing sites, landing pages, isolated components. They fail, often invisibly, on Shopify themes, because Shopify's nested-block architecture is full of places where a decision in one component depends on the whole system. That's exactly the kind of judgment current agents handle least reliably. The build is commoditizing. The judgment about where things go and what breaks is not.
"The AI just builds it" is true, until it isn't
There's a demo that's become impossible to avoid: paste a design into an AI tool, get working code back, ship it. On a marketing page, it largely works. A developer I trust pointed one of these agents, armed with Google's own modern-web guidance for coding agents, at his own marketing site, and it found a handful of performance and accessibility problems and fixed them cleanly. That's real. I use these tools every day.
The trouble is that "Shopify development" and "building a web page" look like the same job and aren't. A merchant sees a product page and assumes it's a page. A theme developer sees a system of components that have to negotiate with each other, and with Shopify's data model, an app's output, and a customer's selections, all at once. The AI sees the first thing. The cost of the difference shows up later, on the part nobody demoed.
The "simple" build that's secretly senior-tier
The clearest illustration I've seen is the test an agency owner in a developer community I'm in uses to screen senior Shopify developers, handed round a thread of them for estimates: build a quantity selector and a subscription picker on a product page, with a price that updates on the add-to-cart button. On a clean, modern theme. It looks like an afternoon.
Their estimates ran from about three hours by hand up to a day and a half once you price in QA, responsive behavior, accessibility and browser testing. One of them, using an AI agent against a clean spec, had something functional in twenty to thirty minutes. That's the uncomfortable half of this, so I'll leave it in. The distance between twenty minutes and a day and a half isn't typing speed. It's everything the twenty-minute version hasn't accounted for yet. The most experienced people in that thread didn't talk about the code at all. They talked about the trap-doors:
- The quantity options are variants, so something has to map every option to the right variant, and the right variant to the right quantity.
- The price on the button has to reconcile a quantity discount and a subscription percentage at the same time.
- Some labels ("2 Bars") don't correspond to any standard variant field, so they have to come from somewhere else.
- Currency formatting, the part that keeps getting underestimated, has a genuinely hard version hiding in it: round the whole-dollar prices but not the ones with cents.
- And on a catalog with hundreds or thousands of variants, resolving which selected option maps to which variant, when some of those variants are unavailable, is, in the words of one veteran of that thread, "the most complex Shopify problem I've come across."
None of that is visible in the screenshot. All of it is where the week goes. An AI agent will happily produce something that looks right and silently mishandles one or two of those. The place you find out is a customer checking out at a price you never intended.
The build layer is getting cheaper, fast. "Build" was never the whole job.
Why this happens: components that can't see the system
Marketing pages are forgiving because each section is mostly self-contained: a hero is a hero, a feature grid is a feature grid. AI is strong there precisely because the context a component needs is local.
Shopify themes are the opposite. A modern theme is assembled from blocks that nest inside other blocks, up to eight levels deep, and each block is meant to be reusable anywhere. Shopify's own documentation is explicit about the consequence: because a block can be nested across various sections and blocks, "it isn't always possible to determine ahead of time where the data will come from." The escape hatch Shopify provides reaches the nearest product, collection, article, blog, page or metaobject: a targeted lookup, not general awareness. A block, by design, does not know the context it was dropped into.
So the hard work isn't writing any single block. It's identifying the places where a global pattern needs to be introduced and maintained consistently across components that can't see each other. That "where does this rule actually need to live" judgment is where I see current AI agents struggle most. One veteran theme developer, watching a single modern CSS feature, container queries driven by an element's own inline size, used inside nested blocks, and reported his coding agent going zero for ten across one month. Not because it can't write CSS. It's because it can't hold the system in view.
There's a quieter version of the same problem hiding in performance. The same element can be animated two ways that look equally smooth; one triggers a repaint and performance craters, the other costs close to nothing. Both pass code review. Neither the AI nor the screenshot tells you which one you got. A profiler does, and someone has to know to open it.
So the most useful filter I've found isn't "is the AI good?" It's "does this task need to understand the whole system, or just this corner of it?" Marketing page: just the corner. Shopify theme refactor, variant logic, checkout-adjacent work: the whole system. Hand the first to the machine. Keep a person on the second.
What to do about it
If you're a merchant: use AI for what it's good at without assuming it's good at everything. A landing page, a content section, a one-off component: great. Anything that touches variants, pricing, checkout, the cart, or structured data: that's where you want someone who'll identify the trap-doors before writing code, not something that ships a plausible-looking version and leaves the failure for future-you. The risk with AI on Shopify isn't bad code you can see. It's confident code that's subtly wrong in the exact places customers transact.
If you're hiring or evaluating: stop testing whether someone can produce code. AI made that table stakes. Test whether they can identify what's hard about a deceptively simple build and talk through their decisions. The senior voices in that thread kept converging on the same point: the job is increasingly communication, scoping, and judgment: knowing what to ask, what will break, and what's actually being requested, not typing. The person who can name the five trap-doors is worth more than the one who shipped a working demo in twenty minutes.
The same failure, one layer up
Confident-but-wrong is not unique to AI. It's the default condition of most of what a merchant gets told about their own store. The ad platform reports the conversions it wants credit for. The app dashboard reports the wins it attributes to itself. The optimizer reports a score. Each of those is a self-report from a party with an interest in the answer, and each one looks exactly as plausible as generated code that mishandles the second variant, right up until someone checks it against what actually happened.
Which is why the thing I sell isn't code. I measure what your money (ad spend, apps, tracking) is actually doing, instead of trusting what the platforms and vendors report. It's the same move the product page needs, pointed at the invoice: don't accept the summary, go and read the thing being summarized.
The bottom line
The build layer is getting cheaper, fast, and pretending otherwise is a way to lose. But "build" was never the whole job. The part that's getting more valuable as code gets cheaper is the judgment about where a problem actually lives, what it touches, and what quietly breaks: the part that needs to see the whole system at once. That's the part I sell, and it's the part AI is, for now, least able to replace.
So when someone tells you the AI just builds it: agree, then ask what happens on the product page when the second variant is out of stock. The answer to that question is still worth paying for. Grab a slot and bring either one: the "simple" build that's gone sideways, or the line on your bill you can't account for. Both start the same way: checking what's actually there.
