Craft Anything Turns Your Coding Agent Into a Rebuild-and-Compare Loop

A rebuild loop with a scorecard, and a clean-room default that limits what the agent reads

Ask a coding agent to "build something like this website" and you get a confident guess. It looks at a screenshot or reads your description, writes a lot of code, and calls it done. Whether the result actually resembles the original is your problem. You open both side by side, squint, and type corrections.

That missing step, the comparison, is where most of the time goes. And it's exactly the step a new open-source project hands back to the machine.

Craft Anything sat at #1 on Trendshift's daily GitHub board on November 3, one day after its v0.3.0 release. It studies a website, app, or game, has a coding agent build your own version, compares the build with the original, lists what doesn't match yet, and refines until it is close.

The result is a different way to think about AI rebuilds. The agent's first draft stops being the product. The comparison loop is the product, and the draft is just its first input.

There's a second idea hiding in here that matters just as much: what the agent is allowed to look at. Craft Anything makes that a setting, and the default is the careful one.

What Craft Anything actually is

Craft Anything is a desktop app and command-line tool written in Rust. It doesn't contain its own AI model. It drives a coding agent you already have signed in on your machine.

Its README describes four steps:

1. Study. It inspects the original: pages at every width, and, depending on mode, code, files, and how the thing runs.
2. Build. A coding agent builds a new project in the language, framework, or game engine you name, or a default.
3. Check. It compares the build with the original and lists what doesn't match yet.
4. Ready. You open, play, or preview the result, or ask for changes.

Claude Code is the first supported builder. The README says the tool runs your own unmodified claude program with your own sign-in and never handles your account, which also means your usage falls under your own agreement with Anthropic. GitHub's Copilot CLI and several other agents that speak ACP (the Agent Client Protocol, a common way for apps to drive coding agents) are supported too.

It aims wide. The README lists websites, desktop and phone apps, games (with rebuilds in Unity, Unreal, or Godot), and files. Under the hood its inspection engines cover native programs, .NET, Java, Android, Electron apps, firmware, and more.

The part that matters: the Check step

A coding agent without a check is a cook who never tastes the soup.

Craft Anything's README says "every build is compared with the original," and names what it compares: website pages at three screen widths, a game's own self-test, and an app's runs. The app shows "how alike" the build is, and the build is refined until it is close.

That turns a vague request into a loop with a target. Instead of "make it look like this," the agent gets "here are the specific places your build differs, at each of three screen widths." That kind of feedback is what agents are good at acting on.

The scorecard is more concrete than the README lets on. The project's status document at v0.3.0 defines website likeness as the average of a layout score and a fine-detail score, both measured with SSIM (structural similarity, a standard way to score how alike two images look), averaged across pages. It leaves out parts of the original that change on their own, found by photographing the page three times, so a rotating banner doesn't count against you. The loop stops after up to six refinement rounds, or once a website reaches 90% likeness.

That 90% is a picture score, not a promise that buttons work. Behavior checks for apps and games are listed as partial in the same status notes. For websites, the visual comparison is the solid part.

Clean room versus deep: the setting that decides what the agent sees

The second idea is the one I'd pay the most attention to.

Craft Anything has two modes, and the README is direct about both.

Clean room is the default. In it, "nothing inside the original is read, not its code, files or page source." The tool works only from what a visitor can see, plus any pictures you add. The v0.3.0 release notes tightened this further: captures now drop class names and query strings, and browser evidence records when a run happened in clean room mode.

Deep mode uses every tool, "for your private use." That includes reading a program's code and files, a website's JavaScript, and running Ghidra (the NSA's open-source reverse-engineering suite) when it's installed.

The name borrows from clean-room engineering, where one team describes what a product does and a separate team, which never sees the original code, builds from that description. Craft Anything's clean room mode is a software version of that wall. It isn't legal advice, and it doesn't make every rebuild fine. But it changes what the agent can lift. A model that has only seen the rendered page can't paste the original's source into your repo, because it never had it.

Two caveats from the project's own status notes. The rule that keeps a clean-room builder out of the original's folder and site applies "with Claude Code, and with ACP agents for what they ask about; other agents aren't held to it." And at v0.3.0 the status table says "no live Clean room build run yet." The wall is designed and tested in parts, not proven end to end. Stick with Claude Code if the clean room matters to you.

The README adds a few more rules: use the tool "on software you own or are allowed to examine," it "never bypasses DRM, logins or anti-cheat," and the agent is told "not to copy logos, photos or text unless you confirm you own them or have permission."

Read those as the project's intent, not as a guarantee. An instruction to an agent is a request, and agents sometimes ignore requests. The real protection is the mode switch, because it controls what the agent can see in the first place.

So here's the practical rule. If you're studying a competitor's public website to learn how a layout works, stay in clean room. If you're rebuilding your own legacy app, where you own the code, deep mode is the one that gets the most out of the tool.

Put this into practice

The lowest-friction path is a website you own, in clean room mode, from the command line.

What you need. Rust 1.97 or newer, and a coding agent signed in on your machine (Claude Code is the tested path). On Debian or Ubuntu, the desktop app also needs system libraries:

sudo apt-get install libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libgtk-3-dev

Install and check. From the README:

git clone https://github.com/storytold/craft-anything && cd craft-anything
cargo run --release -p craft-anything
cargo install --path apps/craft-anything-cli
craft-anything-cli doctor

The cargo run line builds and starts the desktop app; the cargo install line adds the command-line tool. The doctor command "checks the install, coding agents and engines" and reports what's missing before you build. Fix anything it flags first. It's faster than debugging a failed rebuild.

Run a first rebuild. Point it at a site you control:

craft-anything-cli rebuild https://your-site.example "Recreate this website"

What to expect: the tool studies the pages, hands the work to your coding agent, and then compares. The comparison is the part to watch. Read the list of mismatches it produces. That list is the most useful thing the tool makes, even if you never ship the rebuild, because it is a precise description of what your site does at each screen width.

Plan for cost and time. The README gives no pricing, but that doesn't mean free. The cost is whatever your coding agent and any connected services charge, and with up to six refine rounds per build, every page can mean several rounds of agent work on your plan. Image and 3D generation are opt-in and use your own fal.ai key. Start with a single page before you point it at a whole app.

Honest limitations

It is early alpha, and it says so. The README's status section lists building with API keys and other coding agents as "built, not yet run live," the Codex adapter as unverified on a real install, and some engine tools as tested only against stand-ins. Claude Code is the path most likely to work today.

The similarity score measures looks. The SSIM-based likeness score is documented in the status notes, but it compares pictures. A rebuild can score 90% and still have a broken form. Read the mismatch list and click through the result yourself.

A clean room is a technique, not a license. Rebuilding something from its visible behavior can still raise trademark, design, or terms-of-service questions. The tool's mode switch limits what the agent reads. It doesn't decide what you're allowed to publish.

The name isn't open source. The code is dual-licensed MIT or Apache-2.0 per the README, but the ArtCraft name, wordmark, and logos are trademarks outside that license, and published modified versions must remove them. Bundled fonts, icons, and images keep their own licenses, listed in ATTRIBUTION.md.

Deep mode means real reverse engineering. Reading binaries and JavaScript is powerful and squarely in "private use" territory. Use it on your own software.

Where this leaves you

The habit worth stealing from Craft Anything works even if you never install it: never accept an agent's rebuild without a comparison against the target, and decide up front what the agent is allowed to see.

If you have a legacy site or internal tool you've been meaning to port to a new stack, this is a cheap experiment. Run doctor, run one page in clean room mode, and read the mismatch list. Whether you keep the build or just keep the list is your call.

Sources: storytold/craft-anything README and v0.3.0 release notes and docs/STATUS.md at v0.3.0 (release November 2, 2026, reviewed November 3, 2026), Trendshift daily board (read about 15:12 ET, November 3, 2026).