Are Page Builders Dead in the AI Era?

Key takeaways

• Drag-and-drop page builders solved a 2015 problem - merchants who can’t code - with a 2015 architecture: widget runtimes, app-rendered pages, and JavaScript shipped on every visit.
• AI changed the constraint, not the need. If plain English can produce native theme code, the drag-and-drop layer stops being the interface and starts being overhead.
• Shopify itself is closing in from below. Horizon’s AI block generation and Sidekick’s theme editing now cover jobs merchants used to install a builder for.
• “Dead” is still overstated. Visual control is a real interface, prompt trust is not universal, and mature builder ecosystems don’t evaporate in a year.
• The honest answer: the category is being rebuilt, not buried - around prompt-to-native-code generation with visual refinement on top.

Every few months someone declares a software category dead, and the category mostly ignores them. So let me be precise about the claim that AI page generation has made drag-and-drop builders obsolete, because half of it is true and half of it is marketing.

The true half: the architecture most drag-and-drop page builders were built on - a widget runtime rendering your pages through the app’s JavaScript - is aging out, and AI is the reason. The false half: that merchants will stop wanting visual control over their storefronts. They won’t.

Full disclosure before a single argument: we build Fudge, an AI page builder for Shopify, and we compete in this category. You should read everything below knowing we have a stake in the answer. We’ve tried to earn your trust by steel-manning the other side properly.

Why you can trust us

We build Fudge, an AI Shopify page builder with a 4.9 rating on the Shopify App Store, which means we compete directly with the tools this article is about - and that’s exactly why we’re showing both sides rather than writing a victory lap. We’ve also installed, tested, and benchmarked every major drag-and-drop builder for our published comparison matrix, so the claims here about how they work are drawn from documented testing, not vibes.

Where a claim is opinion, it’s framed as opinion. Where it’s fact, it’s footnoted.

What page builders were actually for

Rewind to roughly 2015. Shopify themes were rigid, sections-everywhere didn’t exist yet, and a merchant who wanted a custom landing page had two options: hire a developer or don’t.

Page builders solved that with the best interface available at the time: a visual canvas with draggable blocks. PageFly, Shogun, GemPages, Replo and the rest let a marketer compose a page by hand, no code required, and the category earned its success honestly.

But the interface came bundled with an architecture. To render arbitrary block layouts on top of any theme, most builders ship their own runtime: pages are assembled or hydrated by the app’s JavaScript, hosted logic lives in the app’s layer, and the page depends on the app staying installed and paid for. That was a reasonable trade in 2015. The question is whether it’s still a reasonable trade when code itself became cheap.

The case for “page builders are dead”

Here’s the strongest version of the bear case. Parts of it are our opinion; the load-bearing facts are sourced.

1. AI now produces the thing builders were a workaround for

The entire drag-and-drop category exists because merchants couldn’t write theme code. AI has made native-code first drafts dramatically cheaper and faster - the constraint has weakened, not vanished, but it has weakened enough that the workaround has to re-earn its place.

In 2026, describing a page in plain English and getting working, native Liquid back is not speculative - it’s how general-purpose coding agents work, it’s how our product works, and it’s the direction Shopify’s own tooling points. We laid out the full argument in the new Shopify AI development model: when natural language compiles to native code, every abstraction layer that existed to avoid code has to re-justify itself.

A drag-and-drop canvas was never the goal. It was the best available interface to an output merchants couldn’t produce themselves. Once a sentence produces the output, the canvas is no longer the only interface, and the runtime that powers it is no longer a necessary cost.

2. Shopify is building the replacement into the platform

This is the part of the bear case that has hard dates attached.

In the Summer ‘25 Edition, Shopify shipped Horizon, its new theme foundation, alongside AI theme generation (“describe your brand and generate a personalized theme”) and AI block generation - “just say what you want and AI makes it real,” in Shopify’s own words.¹ That is prompt-to-theme-block, first-party, free.

The Winter ‘26 Edition went further: Sidekick now edits themes from a prompt and can create custom blocks in any Theme Store theme, not just Horizon.² The simple jobs that drove a lot of builder installs - a new section here, a styling change there - are becoming a chat message in the admin.

Our read, stated as opinion: Shopify won’t kill the page-builder category itself, because first-party tools historically stop at “good enough” and leave the depth to apps. We wrote about where Sidekick runs out in the state of Shopify AI in 2026. But Shopify is relentlessly compressing the bottom of the market - and the bottom of the market is where widget builders acquired most of their customers.

3. The architecture costs compound in ways they didn’t in 2015

The widget-runtime trade-off got worse over time, for three documented reasons.

Page weight now has a measurable price. App-layer builders render pages through their own JavaScript, which adds weight to every page load. Google has confirmed Core Web Vitals are used by its ranking systems, with targets of LCP under 2.5s, INP under 200ms, and CLS under 0.1³ - one search and user-experience consideration among several, alongside what slow pages do to conversion. Either way, a runtime you pay for in milliseconds, on every visit, forever, is a very 2015 thing to accept in 2026.

Lock-in is the default, not the exception. With PageFly, Replo, GemPages, and Shogun, pages render through the app’s layer and stop displaying when you uninstall - a trade we documented tool-by-tool in our comparison. Ten years of published pages tied to a subscription is a liability that only grows.

The editing ceiling never moved. A block library is a menu. If the layout you want isn’t on the menu, you’re back to hiring a developer - the exact problem the builder was installed to solve. AI generation has no block library, because it writes code; the ceiling is whatever your theme can render.

Put those three together and the bear case writes itself: the interface is replaceable, the platform is absorbing the easy jobs, and the architecture is a depreciating asset. That’s not a category with a comfortable decade ahead.

The case against: why “dead” is lazy

Now the other side, argued honestly - because if you only read the section above, you’d make bad decisions too.

1. Visual control is an interface, not a crutch

Watch a marketer fine-tune a hero section - nudge the spacing, swap the crop, test three headline sizes - and you’re not watching someone route around a skill gap. You’re watching direct manipulation, which for some edits is genuinely the fastest interface humans have invented.

A prompt is a wonderful way to create a page. It is a clumsy way to move a button four pixels. Any account of the category’s future that ends with “everyone just types sentences forever” is skipping the last decade of interface research. The canvas earned its place for refinement work, and it keeps that place.

2. Prompt trust isn’t universal, and the skeptics aren’t wrong

Plenty of merchants have watched an AI tool produce something confidently wrong. Their conclusion - “I want to see and touch what goes on my store before it ships” - is rational, not backward.

Drag-and-drop offers a kind of certainty AI generation still has to earn: the output is exactly what you clicked. Variance between two runs of the same prompt is real, even if it’s shrinking. For a store owner whose storefront is their entire business, “predictable and slower” over “fast and probabilistic” is a defensible preference in 2026.

3. Mature ecosystems don’t evaporate

PageFly alone holds a 4.9 rating across thousands of reviews on the App Store.⁴ Behind numbers like that sit template libraries, integration ecosystems, agencies with deep muscle memory, and thousands of stores whose pages work fine today.

Categories with that much installed base don’t die on a thesis. They erode at the edges while incumbents adapt - and the incumbents are adapting, bolting AI generation onto their editors (GemPages’ image-to-layout, Shogun’s AI sections, Replo’s AI generation). Whether AI-on-top-of-a-widget-runtime is enough is the open question, but it’s evidence the category intends to evolve rather than expire.

What actually replaces them

So: not dead. Rebuilt. Here’s the shape we think the rebuilt category takes - and yes, this is the part where our product thesis and this article’s thesis are the same thing. Judge accordingly.

The tool that wins the next decade combines three properties:

1. Prompt-to-page as the creation layer. Describing a page is faster than assembling one, full stop. First drafts should take seconds, and the describe-refine loop should handle the 80% of edits that are semantic (“tighten the hero, add a testimonial row”) rather than spatial.

2. Native code as the output layer. The page that gets published should be Liquid, CSS, and HTML in your theme - no runtime JavaScript assembling it in the browser, no dependency that breaks at uninstall, nothing between your customer and the page. This is where the 2015 architecture gets retired, and it’s the property that separates AI page builders from AI features inside widget builders.

3. Visual refinement on top. Click the element, change the thing, see the result - because the case for direct manipulation is correct. The canvas doesn’t disappear; it stops being the rendering architecture and becomes what it always should have been: an editing surface over code you own.

That combination keeps what drag-and-drop got right (visual control, no code required) and drops what it got wrong (the runtime, the lock-in, the block-library ceiling). It’s where Fudge sits, it’s where Shopify’s first-party tooling is converging from below, and it’s where we’d bet the surviving incumbents end up too - if they can swap their rendering architecture without breaking a decade of customer pages, which is a much harder migration than adding a prompt box.

What to look for, whichever side you pick

Before you install anything, you can see what prompt-driven design actually produces on your own store: our free Shopify website redesign tool builds three homepage directions from your real products and content, no app required.

You don’t have to buy our thesis to shop well. Whether you land on an AI-first tool or a mature drag-and-drop builder, the same five questions expose the trade-offs:

• What is the published output? Native theme code, or markup rendered through the app’s runtime? This one answer predicts most of the others.
• What happens on uninstall? Ask the vendor directly, in writing. “Pages keep working” and “pages keep working while our script tag stays in your theme” are different answers.
• What does it cost in milliseconds? Run Lighthouse on a page built with the tool versus your plain theme. Core Web Vitals are one ranking and user-experience input among several,³ so this is a revenue question, not a nerd question.
• Where is the editing ceiling? For block-library tools: what happens when the block you need doesn’t exist? For AI tools: what happens when the prompt doesn’t land - is there a visual way to fix it, or just re-rolls?
• Does first-party Shopify already do this? Post-Horizon and post-Sidekick, a real slice of builder use cases became free platform features.¹² Check before paying a subscription for one.

For ranked recommendations by use case, our best Shopify page builders guide applies exactly this rubric across the whole field, including tools that beat us on specific dimensions.

Our verdict

Are page builders dead? No - but the thing that made them a distinct category is dying.

The drag-and-drop canvas as an interface survives, absorbed into whatever comes next. The widget runtime as an architecture doesn’t, because both of its justifications weakened at once: AI made native code dramatically cheaper for merchants to get, and Shopify’s own AI absorbed many of the simple jobs that once justified installing an app.

Opinion, clearly labeled: within a few years, “page builder” will mean a tool that generates and edits native theme code, with a visual surface on top - and the products still rendering storefronts through their own JavaScript will read the way Flash sites read in 2012. Not gone. Dated.

We’re biased, because we built for that outcome. But we’d rather show you our reasoning and our sources and let you check the math than pretend we’re neutral.

FAQ