403, a Proxy, and 173,347 Verbatim Bytes: GLM 5.3 Flash Clones a Claude Artifact 1:1

1. The Assignment

The target was not a vague "rebuild this vibe" request. It was a Claude artifact: a self-contained HTML page titled Melon Jelly Knife, billed as Material Studies / No. 009 — a WebGPU soft-body simulation of a slice of melon jelly that you can grab, stretch, and cut with a knife. The success condition was the strictest possible: 1:1. Not "inspired by", not "rebuilt with the same tech". Byte-for-byte behavior, byte-for-byte look.

That constraint matters more than it looks, because it changes what "good" means for the model. A generative task rewards cleverness; a 1:1 clone rewards restraint. Every line the model writes of its own is a potential diff against the original. The correct instinct is to write as little as possible.

2. The Wall

The direct approach died immediately. Fetching the artifact URL on claude.ai returned the region-block page — the full HTML shell renders, and the API underneath answers HTTP 403.

The wall. claude.ai serves its “App unavailable” page to the agent's region — HTTP 403 on the API under a fully rendered HTML shell.

A weaker run would have stopped here and reported failure, or worse, quietly improvised a "close enough" rebuild from memory. GLM 5.3 Flash logged the 403 and started looking for another door.

3. The Detour

The route it found is the interesting part of this run — a three-hop path around the block, each hop verified before the next:

claude.ai/artifact/RiTbBMEqgfNwgMHMTAhf5P  → 403, region block
r.jina.ai/<artifact-url>                   → viewer page loads, title found:
                                              “Melon Jelly Knife”
claudeusercontent.com/<iframe-id>          → full single-file artifact,
                                              212 KB — host is NOT region-blocked

First, the Jina reader proxy (r.jina.ai) fetched the artifact viewer page, which confirmed the target exists and gave up its title. Second, and this is the key observation: the viewer embeds the actual artifact content from a different host — claudeusercontent.com — and that host had no region gate. The model extracted the iframe URL from the viewer HTML and pulled the complete single-file document straight off the CDN: 212 KB including Claude's own frame runtime.

4. Surgery: Fidelity by Construction

With the payload in hand, the problem inverted: the file contains two documents — the artifact, and Claude's sandbox wrapper around it (window.__FRAME_PREAMBLE plus frame-runtime scripts, about 37 KB). The wrapper is what makes an artifact run inside claude.ai; it is not part of the artifact. The split point is explicit in the file: everything after the <!-- /frame-runtime --> marker is the artifact itself.

So the reconstruction is almost embarrassingly simple, and that is the point:

<!doctype html><html>
  <!-- artifact content, VERBATIM after <!-- /frame-runtime --> -->
  ... 173,347 bytes, zero modifications ...
</html>

Copy the marker onward, wrap it in a minimal document, and the clone is guaranteed by construction. Not "verified by eyeballing two screenshots" — guaranteed, because there is no edited line anywhere to get wrong. The run's own summary puts it exactly right: 1:1 clone guaranteed by construction; no changes made to the artifact's code. The worklog also records the hygiene step most runs skip: every intermediate fetch file was cleaned up, and a standalone copy of the deliverable was archived alongside the deployed one.

5. The Only Bug Was in the New Code

To serve the clone at the root URL, the agent stood up a fullstack Next.js 16 environment and added a rewrite from / to /melon-jelly-knife.html. First attempt used the default afterFiles rewrite phase — and the route came back as the app-router's own page, because afterFiles runs after filesystem routes have already claimed the path. One config change later the rewrite moved to beforeFiles, and / serves the clone.

// next.config.ts — beforeFiles, not afterFiles:
async rewrites() {
  return {
    beforeFiles: [
      { source: '/', destination: '/melon-jelly-knife.html' },
    ],
  }
}

Note what did and did not break. The artifact code never broke, because it was never touched. The only failure in the entire run lived in the handful of lines the model wrote itself — and it found and fixed that in the same session, from the symptom (wrong page at /) to the cause (rewrite phase ordering).

6. Verification Without a GPU

The Z.AI sandbox has no graphics adapter, so the full 3D simulation cannot run there — and here the run's honesty is worth quoting. Rather than claiming the sim "works", the verification report says the layout matches the original (masthead, specimen panel, swatches, sliders, stats), and that the visible fallback card — "No WebGPU adapter was found" — is the artifact's own designed behavior for GPU-less browsers. In a real browser with WebGPU, the jelly wakes up.

The deployed clone on Z.AI Spaces, in the sandbox's GPU-less browser. The “Renderer offline” card is not a broken clone — it is the artifact's own designed fallback, and its presence at the right place with the right copy is itself evidence of the 1:1 copy.

That distinction — "the environment can't run it" versus "the clone is broken" — is exactly where sloppier runs lie to you. Verification that reports what it can see, and names what it can't, is worth more than a green checkmark.

7. What Got Cloned, Exactly

Worth pausing on what those 173,347 bytes contain, because the artifact deserves its own credit. Melon Jelly Knife is a complete WebGPU application in one file: an XPBD (extended position-based dynamics) physics core stepping at 60 Hz with 10 substeps, co-rotational elastic constraints plus volume constraints for a near-incompressible jelly; a tetrahedral mesh with the skin, seeds, and bubbles attached by barycentric weights; and a renderer doing Beer–Lambert absorption, thickness-based refraction, Fresnel reflections, and GGX highlights. Around the simulation: hand and knife tools, three varieties (Crimson, Golden, Rosé), firmness and damping sliders, live readouts of mass, volume, kinetic energy, and piece count — and a deadpan specimen-lab presentation, fig. 9 included, with the best tagline in the genre: "A slice of summer. A little wobble. Too soft to share."

What the 173,347 bytes actually render: the clone running on hardware WebGPU — Beer–Lambert jelly, embedded seeds, live readouts (mass ≈78 g, 97.3% of rest) and the LIVE badge. This is the original artifact's work, byte-verbatim.

None of that came from GLM 5.3 Flash, and the run never pretends otherwise. Its contribution was the retrieval, the surgery, the serving, and the verification — the engineering around the artifact, not the artifact.

8. Then It Went Further: Three Melons Became Eleven

A 1:1 clone is where most runs stop. This one did not. A second task in the same session asked the agent to extend the cloned artifact with more fruits and objects — and this is where the job changes shape entirely. Cloning rewards restraint; extending someone else's 186 KB hand-rolled WebGPU engine rewards comprehension. There was no spec to copy from anymore. GLM 5.3 Flash had to read the original architecture — the pie-shaped SDF wedge geometry, the palette system, the seeded RNG that places seeds and bubbles, the way globalProps() re-embeds seeds after every cut, the installWorld() rebuild path, the camera auto-fit constants, the XPBD soft-body core — and then design new content that behaves like it was always there.

What it designed, from scratch, inside that engine:

• A second geometry family. The original could only cut pie wedges. The agent added a disc outline family alongside pie — a new SDF branch, new outline sampling, a new CCW polygon builder — which is what makes full-round slices possible at all.
• Four citrus specimens (Orange, Grapefruit, Lemon, Lime): wedge slices with thick pith bands, no stripes, no seeds — the correct anatomy, not just a recolor.
• Dragonfruit: white flesh carrying 53 tiny black seeds under a magenta rind.
• Kiwi: a full disc slice with a black seed ring and a pale core, achieved through the artifact's own fleshDeep mechanism.
• Two non-food objects: a translucent Jelly mould and a Glacier ice puck — uniform translucent discs with extra bubbles and no rind bands at all, proving the system generalizes past fruit.

The extended VARIETY panel: Crimson, Golden, Rosé (the untouched originals) joined by Orange, Grapefruit, Lemon, Lime, Dragonfruit, Kiwi, Jelly mould, and Glacier.

Each specimen is a full simulation profile, not a color swap: shape parameters, palette, a seed layout expressed as fractions of the inner radius, a bubble count, a physical density, a figure number, and its own editorial copy. Switch to Orange and the whole page rewrites itself — the masthead becomes Orange Jelly., the tagline becomes “A wedge of sunshine. Pith over pulp. Peel with intent.”, the figure counter moves to fig. 12, and the footnote's density changes from gummy at 1.3 g/cm³ to citrus at 1 g/cm³. Even the mass readout follows, because mass is summed live over every tetrahedron at the specimen's density.

The discipline part nobody asks for

The hardest constraint was invisible: the original three melons had to remain pixel-identical. Seeds and bubbles come from a seeded RNG, so any change to the number or order of R() calls would shift the random stream and scramble Crimson, Golden, and Rosé. The agent preserved the call order exactly — seeds 40, bubbles 11, untouched — so the three originals render bit-for-bit as before while eight newcomers slot in around them. When you switch between the melon trio, the specimen recolors in place with zero rebuild; only a shape-family change (melon wedge to kiwi disc) pays for a full geometry and physics rebuild. And the camera now auto-fits to each specimen's outer radius, so a small lime frames as correctly as a big melon.

Orange under hardware WebGPU: a brand-new specimen the original never contained. New masthead, new caption, fig. 12, citrus at 1 g/cm³ in the footnote, mass readout re-summed to ≈48 g — and the pith band is geometry, not a texture.

What this says about GLM 5.3 Flash and 3D models

The clone proved retrieval and fidelity. This run proves something rarer: the ability to author new physically-simulated 3D models inside an unfamiliar engine. Working blind in a 186 KB single file of hand-written WGSL render passes and XPBD physics, it produced eight new soft-body bodies with the right anatomy (pith bands, seed rings, translucent interiors), the right material behavior (Beer–Lambert absorption over each new geometry), and the right interaction with the cutting sim (cuts through a kiwi disc split it into valid pieces and the seeds stay embedded). That is the same skill set you would want for generating similar 3D content in any engine: read the scene graph, respect the random stream, add content the existing renderer can light and the existing physics can wobble.

Dragonfruit under hardware WebGPU: white flesh, 53 individually placed black seeds, magenta rind — its own tagline (“Dressed for the runway. Quiet inside. Full of stars.”), its own density (1.05 g/cm³), fig. 16.

The verification kept the same honesty standard as the clone. Three independent layers: node --check on the syntax; a live CDP session with SwiftShader WebGPU that actually switched to Orange on a running device and rebuilt mesh, UI, and readouts with zero console errors; and a Node test suite (scripts/test_specimens.mjs) that builds all eleven specimen meshes headlessly and asserts finite vertices, positive tetrahedra, the exact seed and bubble counts per config, SoftBody initialization, and that a centre cut splits a disc into two valid pieces. Eleven of eleven passed. The known limitation is stated, not hidden: SwiftShader devices die within seconds in the sandbox (the original artifact dies identically), so full visual confirmation comes from the hardware-WebGPU screenshots below.

The cut test, visible at last: one swipe of the knife and the melon splits into two valid pieces — PIECES reads 2, volume holds at 99.9% of rest, seeds and rind follow the cut plane. This is the assertion the headless suite checks on all eleven meshes, now shown on real hardware.

Kiwi, the disc family's showcase: a full-round slice with a black seed ring and pale core, lit by the original's own renderer. The camera auto-fit scales to its outer radius — same framing quality as the big melon wedge.

9. Try It

Open it in a WebGPU-capable browser (Chrome or Edge on a machine with hardware acceleration; Safari 26 also qualifies), cut yourself a slice — then hop the VARIETY swatches. Cut a wedge out of the orange, saw a kiwi disc in half, tap the Glacier puck and watch the bubbles drift. All eleven run on the same physics; only one of them was in the original.

10. The Score That Isn't a Score

We don't hand out numeric verdicts on this blog, so here is the honest one-sentence summary: given the strictest possible brief — identical, not inspired — GLM 5.3 Flash treated a hard block as a routing problem, chose the route that made correctness structural instead of tested, and told the truth about what it could and could not verify. Then, on its own extension pass, it read another engine's physics cold and grew the collection from three melons to eleven specimens without disturbing a pixel of the original. The jelly was never its work. Getting the jelly to you, intact, was — and then the other eight jellies were.