Craft Anything: Your Claude Code Clones a Site, Then Grades It

0:00Craft Anything is a free, open-source Rust app from the ArtCraft team — the same studio that shipped free substitutes for Adobe's apps. You point it at a website, it studies the page the way a visitor sees it, your own signed-in Claude Code builds a fresh version, and then the tool screenshots the copy, compares it with the original and loops until the two look alike. 0:02The maker reports one clone at 96% likeness.

0:09That number is the whole story, so it deserves to be read properly. The video's method was to go and read the grading code. This article does the same and goes further: every default, threshold and scoring formula below is quoted from the repository's source, and every status claim from the project's own STATUS.md.

The 96% claim

0:13The run behind the number is logged on the project's status page: 2026-10-18, Windows 10, headless CLI, a website clone reached Ready at 96% likeness in 1.5 minutes. 0:41One clone, one machine, one run — and the status page does not say which mode was used, which matters later, because the tool's headline mode is the one with no live build run yet.

What is easy to verify is that the project is real and moving fast. storytold/craft-anything went public on 31 October 2026 and by 7 November had 18,306 stars, 3,382 forks and 217 open issues; 64 contributors, and five releases in six days (v0.1.0 on 31 Oct to v0.5.0 on 6 Nov). It is dual-licensed MIT / Apache-2.0 — GitHub's API reports plain Apache-2.0 because it picks up LICENSE-APACHE, but the repo ships both files and the README badge says MIT OR Apache-2.0.

Why copying by hand breaks at the third width

0:19The manual version of this job: screenshot the page, poke at it with inspect-element, guess the spacing by eye, write CSS until your laptop looks right. 0:29Then it isn't right, because a modern page is not one picture — it is at least three layouts. The content column narrows, items per row drop, section padding and heading sizes change, and menus that are a hover on desktop are a different animal on a phone.

0:35The classic failure is exactly what the video describes: it looks perfect on your laptop, and on a phone the headline runs off the edge and you scroll sideways to read it. That is a layout bug no single-width check can catch, and it is what this tool is built around.

Study → build → check → refine

0:41Craft Anything turns the copy job into a loop with four named steps, and its own documentation is unusually explicit about what each one captures:

0:47The maker's own live test points at example.com — deliberately the smallest interesting target: one short paragraph and a link. 0:53The builder produces its version, the tool lists what doesn't match, and round two begins. The defaults live in one struct in crates/engine/src/settings.rs:

The loop is not only a final gate: the builder can call the same check itself mid-turn, so it can grade its own work and keep going before it ever hands back. A turn cut off by a time limit, crash or dropped connection resumes — up to three times — and builder turns may run up to 24 hours. And websites are only one of three kinds: app (Rust + egui by default) and game (Unity, or the original's engine when it is Unreal or Godot) go through the same four steps.

Clean room: what the builder is allowed to see

1:01The default mode is called Clean room, and it is a rule about evidence, not about effort. In Clean room the capture keeps only what a visitor can see: no HTML, no CSS rules, no scripts, no network requests, no load errors. The builder gets screenshots, visible text and measured layout — never the original's markup.

1:34The video's image for it is a tailor copying a suit by measuring it on a mannequin without unpicking a single seam. The opposite mode is Deep: every tool switched on, the builder reads the site's JavaScript and watches the start page for ten seconds, and if Ghidra is installed its decompiler joins in so compiled programs can be turned back into readable code.

1:25Who builds it is the neat part: your own unmodified Claude Code, signed in with your account, with Craft Anything's MCP server and permission tool attached. 1:31So every clone runs on the subscription you already pay for. The docs are explicit about the boundary: it never reads, stores or forwards credentials or tokens, offers no Claude login of its own, and doesn't pay for, resell or meter Claude usage. A preflight runs claude auth status first, and stops the build with a plain "sign in to Claude Code" message if you aren't signed in.

The leash: approvals, not a sandbox

1:35"An agent running a whole build alone should make you nervous" is the sentence that earns the section. The mechanism: every action that isn't read-only is routed through one approval tool, mcp__craft-anything__core_action_approve.

• 1:43Allowed outright: edits inside the project's app/ folder, and a fixed list of build commands (npm install, npm run build, cargo build…). Dev servers are refused — they never exit.
• 1:49Everything else is decided by kind — the web, commands, files outside the project, pushing and publishing, deletes outside the project, system changes — and each project can set allow / ask / refuse. An unchosen kind follows Auto mode, which is permissive by default.
• 1:39In Clean room the read rule is enforced the same way: reads go through the approval tool too, which refuses anything inside the original's folder or on its site.

1:51And the one the video underlines: Clean room does not sandbox your computer. Clean room restricts what the agent may see of the target; it does not restrict what the agent may do to your machine. The README puts it plainly — "a coding agent you run still acts as you, and what it can read, write or run depends on its own permissions" — and adds a warning most tools of this class leave out: installing dependencies runs code. npm install executes every package's install scripts by default; turning on "always allow" for npm means every later npm command runs without asking. The README's own mitigation is to run npm install --ignore-scripts.

What the score actually measures

1:58Here is where reading the code pays off. At each width the check photographs the original and the copy, then calls an image-comparison tool with three non-obvious arguments: compare only the common area, allow a colour tolerance of 24, and ignore a mask of the parts that change by themselves. The score is then assembled from two halves:

2:14The mask is the careful bit. During study the tool photographs the original three times, finds what changed between the shots — carousels, live counters, animations — and stores a noise-<width>.png that the comparison skips. Otherwise a rotating hero banner would cap scores on pages that are otherwise perfect. 2:20The loop then stops at 90% or after the round budget, whichever comes first.

The final arithmetic is (layout + detail) × 50, which is why the number reads as a percentage with each half worth exactly fifty points; if perceptual detail can't be computed, it falls back to the layout figure so a score still exists. With several pages, likeness is averaged over pages and each page's own score is kept.

Worth knowing what that formula is for. A comment in the source states the design intent better than any marketing page could: "Layout alone is generous to mostly empty pages; detail (SSIM) sees text and edges." Tile colours alone would score a blank page with the right background near 100%. Adding SSIM is what stops the metric from being gamed by whitespace.

What the score can't see — and what else fails the check

2:24Nothing in the score tests what a button, form or checkout does. 2:31The video's line for it is the best one in the script: a copy can score high and still be a photo of a shop with painted-on doors.

But the score is not the only gate. The same check also produces claims — assertions that must hold, and a single failed claim makes the check "not good enough" even when the likeness is high:

• A page that scrolls sideways at any of the three widths.
• Script or console errors the build adds, or a file that fails to load.
• A missing landmark (the accessibility outline the original had).
• A menu or pop-up that doesn't open in the build — the check opens up to 8 states and compares each one, per width.
• For games: every self-test step; for Deep-mode sheets: every original number in the code; for console apps: the same exit code and output as the original's runs.

So the honest reading is two-layered: the percentage answers "does it look the same at three widths", and the claims answer "is anything visibly broken". Neither answers "does it work". Functional equivalence is your job, and no number in this tool pretends otherwise.

Where it breaks: three open reports

2:56The project is eight days old with 217 open issues, so the tracker is the most useful page in the repo. Three reports the video picks out, all still open:

The maker caps the rounds for exactly this reason: the docs state that rebuild rounds are bounded "to keep usage ordinary", because advertised Pro and Max limits assume ordinary individual usage. Six Opus-5.5-at-high-effort rounds on a screenshot diff is not ordinary individual usage, and that is the real cost of the loop — not the download.

The clean-room gap, and the Deep-mode line

3:26This is the finding that changes how you read the headline. Clean room is the default and the advertised mode — and the maker's own status page says, in the row about it: "no live Clean room build run yet". The 96% run doesn't state its mode. So the number that sold the tool and the mode the tool opens in have not, on the maker's own record, been demonstrated together.

What has been logged live on that page, all maker-reported: Claude Code on macOS with session resume and handoff, Ghidra 12.1.4 on Windows and 12.2 on Linux doing real decompiles, a DeepSeek Harness follow-up build that reached 100% likeness at 1440/768/390 px in 3 min 10 s, and an ACP agent (Maki 0.7.0) taking a static page to Ready in 38 s. Note the 100%: it was a follow-up build on an existing project, not a from-scratch clone — and it illustrates how a screenshot metric behaves. Near-perfect pixel agreement is achievable; that says nothing about whether the site works.

3:35Deep mode is where the decompiler sits, and it is the mode with real evidence behind it. 3:44The limits are stated rather than buried: it never bypasses DRM, logins or anti-cheat; rebuilds recreate layout, style and behaviour from evidence; and the agent is told not to copy logos, photos or text unless you own them or have permission. 3:50Your use runs under your own agreement with Anthropic, because it's your CLI and your subscription — and the docs go further than most, listing the open legal questions they'd need answered before selling a paid, managed tier.

Install or skip

3:53Install it if you want a fast head start on the look of a page you have the right to rebuild, you already pay for Claude Code, and you'll treat the output as a scaffold. 4:02Skip it if you need working features, if your target sits behind a login (Clean room sees only what a visitor sees, and a login wall is precisely what it can't crawl past), or if your plan limit is already tight.

What I'd actually use it for, beyond the demo:

• Three-width regression on a design you already own. The comparison engine works on any two screenshots of a page — including your own site before and after a refactor. That is a genuinely useful tool even if you never clone anything.
• Porting a static page across stacks, where "looks identical" is the acceptance criterion and there is no behaviour to verify.
• As a reference implementation of screenshot-diff-as-reward for your own agent loops: noise masking, common-area comparison, claims that gate the score. Those three ideas are worth stealing whatever you think of the product.

One caveat worth repeating: 0.5.0 in six days, 217 open issues, and an approval policy that its own docs describe as a raised bar rather than a wall. Run it on a machine and an account you're willing to expose to a coding agent that installs dependencies.

Related on this site: ArtCraft: Claude Rebuilt Adobe's Suite — Free and Open Source, on the same team's earlier run at free, open substitutes for expensive creative software.

📚 Sources & further reading

⏱ Timestamp index