The category has split

Two camps, roughly.

The first is drag-and-drop with AI features layered on top. Foxify, PagePilot, and Atlas sit here. The editor is the primary interface. AI helps you fill sections, generate copy, translate content, or expand a product URL into a ready-made landing page. The underlying paradigm is still manual assembly from pre-built parts, just with better auto-fill. Nothing wrong with that approach. The AI is a feature inside the tool, not the tool itself.

The second camp is prompt-first. You describe what you want, the AI generates the page. QuickPages, Fudge, Replo's AI flow, and Instant's shopdev sit here. The chat or prompt is the main surface, and any visual editor sits behind it for refinement.

You can ship a working page on either side of the line. They feel very different to use, and they produce very different code.

Where the pages actually live

This is the less visible architectural decision, and it's the one that tends to matter most six months in.

Some builders publish pages as native Shopify theme sections. Others wrap content in their own runtime or component model with a thin Liquid export layer. A few route traffic through a custom domain (Replo uses reploedge.com for A/B testing on custom domains). The difference shows up when you want to mix AI-generated content with sections from your existing theme, integrate third-party review or upsell apps, or uninstall the builder without breaking anything.

A quick rundown of how each one handles this:

• Replo can export Shopify sections, but the primary experience is Replo's own visual editor with its component model. Custom domains and A/B tests pass through a Replo proxy. The Liquid export is strong, but the day-to-day isn't native Shopify.

• Instant recently shipped shopdev, which produces Liquid from a prompt. The main product is still a Figma-to-Shopify visual editor backed by a large template library. The prompt flow and the visual flow feel like two products glued together.

• Fudge writes native Liquid, JS, and CSS into the theme with no iframes or proxies, driven by prompts. Architecturally it's the closest cousin to what we do.

• PagePilot and Atlas are dropshipper-focused. Paste a product URL, get a page. Sections are theirs, templates are heavy, and the output is optimised for speed-of-launch rather than theme integration.

• Foxify is industry-template-first with AI copy and translation helpers. Affordable, well-reviewed, and firmly in the drag-and-drop camp.

• QuickPages publishes every generated output as a native theme section inside the Shopify customiser. You edit it with Shopify's own controls, reuse pieces across pages, and mix QuickPages sections with whatever shipped with your theme. If you uninstall the app, the sections stay in the theme.

The choice determines portability, composability, and how much of your store ends up living inside someone else's runtime.

Speed, tokens, and why it compounds

There's an uncomfortable truth about generating full Shopify pages with an LLM: a page is a lot of tokens. A well-built hero with a product grid, testimonials, FAQ, and footer can easily be 800 to 1,500 lines of Liquid once the schema blocks, data bindings, and Tailwind classes are in. Asking a frontier model to write all of that directly is slow, expensive, and error-prone. The longer the output, the more likely something drifts.

We took a different path. The LLM produces a compressed intermediate output that captures the creative and structural decisions in a fraction of the tokens. A deterministic post-processor then expands that into production-ready Liquid with schema, bindings, and classes. No model is involved in the expansion step, so it doesn't fail, doesn't drift, and doesn't cost anything per run.

That one decision compounds across the product. Generation is faster because there's less to produce. Regeneration is cheaper because the compressed format is small. Iteration is viable because you're not paying for a 4,000-token output every time you tweak a prompt.

Side-by-side on a fresh product page, prompt to published section:

• QuickPages: [fill in] seconds

• Instant (shopdev): [fill in] seconds

• Replo (AI builder): [fill in] seconds

• Fudge: [fill in] seconds

On regenerating a single section with a new angle:

• QuickPages: [fill in]

• Instant: [fill in]

• Replo: [fill in]

• Fudge: [fill in]

The exact numbers come from our benchmarks. The shape of the gap is a consequence of how each tool is built.

Brand context with zero setup

Template libraries exist because the tool doesn't know your brand. Giving you 200 "high-converting" layouts to pick from is a way of handing the customisation problem back to you.

QuickPages analyses the store on install: colours, typography, layout patterns, imagery style, tone of voice. Fudge does something similar. Most of the others expect you to either pick a template and restyle it or tweak a few brand inputs manually. If you want generated pages that look like your store, not a generic DTC template, this matters from the first prompt.

Which one is right for you

The honest version.

Running a dropship operation and testing lots of product pages quickly? PagePilot or Atlas. They're built for that workflow.

Design team that lives in Figma and wants pixel control? Instant is the tightest design-to-store flow in the category.

Seven-figure DTC brand with a growth team, a real testing budget, and a need for deep A/B testing and granular visual control? Replo is the category standard at that end of the market.

Budget-conscious and want solid drag-and-drop with AI assists for copy and translation? Foxify is well-loved for exactly that.

Want AI-native page generation that publishes as native theme sections, iterates fast, and doesn't lock your content inside a runtime? That's the camp we're in. Fudge is our closest cousin and worth evaluating alongside us.

We're not claiming to be the only tool that outputs Liquid. Instant, Fudge, and Replo all have Liquid output in some form. The axes we picked are sections-first architecture, chat-first UX, and a compressed-intermediate generation pattern that makes iteration cheap & fast enough to actually iterate.

If any of that lines up with how you want to work, your first page is on us.