On July 21, 2026, Shopify released a developer preview that allows online store page structures to be written in Liquid rather than JSON templates. The new block tag combines reusable components, while the partial tag updates only a portion of a page from the server side. This isn't nostalgia. As merchants have come to rely on the AI assistant "Sidekick" to request theme changes in natural language, and developers have started using coding agents as well, the file structure of themes itself has become an editing interface for AI.
What Shopify is trying to restore is a state where reading HTML and Liquid from top to bottom reveals how a page is assembled. At the same time, they're organizing typed arguments, inspection rules, and instructions within the repository so that AI receives specific errors when it makes mistakes. The developer experience designed for humans and the design oriented toward AI have begun pointing in the same direction.
Bringing JSON-Split Pages Back into a Single Liquid File
In the current Shopify theme structure, JSON templates hold the page structure while Liquid handles the rendering of each component. JSON arranges sections, and each section's Liquid file contains settings and blocks. Merchants can add components through the theme editor and change order and appearance without code. Developers, however, must go back and forth between JSON and Liquid, tracing from schema to blocks, to understand the entire page.
According to Ben Sehl, Product Director for Storefronts at Shopify, this separation was a reasonable choice for giving merchants editing freedom since Sections were introduced in 2016. However, JSON templates became configuration data saved by the theme editor rather than a place where humans write design intent. For AI agents too, the context needed for a single change gets scattered across multiple files.
In the "Liquid July '26" preview, the new {% block %} tag reduces this fragmentation. Templates can now write the block name being called, arguments, and inner HTML right in place. For example, on a product listing page, the outer container, headings, and repeated product cards can all appear together in a single Liquid file. Both developers and agents can trace the page structure from top to bottom.
This isn't a rejection of the JSON format itself. The problem is that the vocabulary of configuration data alone can't express every combination merchants might want later. Even if you wanted to place two buttons side by side, the conventional approach required developers to anticipate this and prepare either a second setting or a block that accommodates both in advance. With a Liquid template, wrapping the two in an HTML div is a localized change that suffices.
Instructions for AI Also Improve the Human Development Environment
According to figures Sehl made public, from the start of 2026 through July 21, Sidekick had been used for 25 million theme edits, with one in five merchants using AI to modify their themes. While the scope of these figures and success rates weren't disclosed, it's clear that AI-driven theme manipulation has moved beyond experimental, minority use. Shopify has rebuilt the theme development environment so that agents receive sufficient context and incorrect outputs can be inspected.
In the new Skeleton Theme, each block begins with a {% doc %} tag that describes the arguments it accepts, their types, and usage examples. Theme Check detects discrepancies between this declaration and the actual invocation and schema. Beyond validating contracts and structure, Shopify has added 20 rules covering everything from complexity to file size. If AI creates an argument that doesn't exist, the system can return an error usable for correction rather than a failure with an unclear cause.
The repository's AGENTS.md serves the same role. In the published Skeleton Theme, it explicitly states things like: don't add JSON templates or sections, route display strings through translation keys, and don't hardcode in-store URLs. This is meant to let developers and agents share design commitments that can't be read from individual files alone.
What makes Shopify's design interesting is that rather than giving AI lengthy explanations each time, it places contracts near the code and closes the loop with mechanical inspection. Typed documentation and static checking are mechanisms human developers have also long sought. Rather than adding a special code layer just for AI, Shopify has built a development environment that humans can read and tools can verify.
How block and partial Change the Boundaries of Implementation
{% block %} is a new placement method that calls existing theme blocks directly from a Liquid template. Because it can pass named arguments and body content, it allows assembly similar to React's props and children. However, this isn't a setup that places a virtual DOM in the browser. Liquid generates HTML server-side, while ordinary HTML and Web Components handle behavior in the browser.
The area where merchants freely add and rearrange content through the theme editor continues to be handled by content_for and JSON. The division of labor becomes: block for places where the template decides the composition, content_for for places where the editor decides, and render for internal reusable code without settings. The new tag doesn't abandon the existing component model—it separates, in code, who decides the page composition.
The other new tag, {% partial %}, names a range that changes, such as a product listing or cart item count. JavaScript uses that name to fetch newly server-rendered HTML and replace only the corresponding area. Previously, responses from the Section Rendering API had to be reconnected to the DOM through client-side code, but with partial, the area name itself becomes the contract for fetching and replacing. This avoids both full-page reloads and client-side logic that reconstructs the same screen.
Even so, JavaScript doesn't disappear. Shopify's documentation lists, as implementation responsibilities, handling race conditions where slow, outdated responses overwrite newer displays, showing loading states, and announcing updates to screen readers. State that exists only in the DOM—like an open or closed menu—must also be restored after replacement. What partial reduces is the wiring for partial updates; it doesn't automate the design and accessibility work that comes with asynchronous UI.
Don't Read the 93% Reduction as Straightforward Productivity
Sehl explained that the new base theme has 93% fewer lines of code than the current Horizon theme. That's a large number. But this isn't a comparison of the same finished theme implemented using old versus new methods. The new Skeleton Theme is a starting point narrowed down to blocks, templates, and basic CSS, and its README itself describes it as "minimal." Horizon, meanwhile, is Shopify's flagship theme, rich with features and design presets.
So the 93% figure indicates how small a starting point the new structure allows—it isn't a measurement showing that maintenance effort would drop by 93% if you migrated. As you build brand-specific pages and components and add styling, the code volume will grow. What should actually be compared is the number of files opened and the number of corrections needed to complete the same change. Errors caught during inspection and post-launch bugs also need to be measured.
A line also needs to be drawn regarding the adoption stage. In existing themes, sections and settings as well as JSON templates continue to work, and migration isn't forced. To try the new tags, developers need to opt into the "Liquid July '26" feature preview, and the behavior of the tags along with the JavaScript helpers may change before general availability. Shopify hasn't announced a general availability date.
It's more accurate to view this redesign not as a story about AI writing more code, but as an attempt to surround the scope AI can modify with readable code and explicit contracts. The material for judging whether this should proceed to general availability isn't a flashy reduction in line count. It's whether, in actual theme edits on real stores, Sidekick and developer-facing agents can complete changes with fewer rounds of rework—and whether Theme Check and humans can verify those results.