Craft Anything: Learn How Software Works, Then Let AI Rebuild Your Own Version

You find a tidy landing page: just enough animation, a sign-up form exactly where it belongs. You want a page like it, but you have no source code, no documentation — only the running interface. A chatbot gives you generic descriptions and sample snippets, but no idea how the original arranges its layout, which colour goes where, or what its menu opens.

With a small game or an old internal dashboard, the problem is sharper: you want to understand the screen flow of a legacy system before rewriting it. Reading assembly with Ghidra works, but it is slow and demands deep expertise. Copying the interface by hand takes an afternoon and still goes wrong.

Craft Anything starts from exactly that bottleneck. It does not promise you the original source code, nor a perfect copy in one click. It observes the real target, records evidence you can inspect, then lets a coding agent on your own machine build a new project from that evidence — and compares the build against the original, refining it in rounds. This article covers how it works, how to install it, the Clean-room and Deep modes, and the limits to know first — this is still early-alpha software, first released on 31/10/2026.

What is Craft Anything?

Craft Anything is an open-source (MIT OR Apache-2.0) desktop app, CLI and MCP server written entirely in Rust, from the ArtCraft team (storytold/craft-anything). Its tagline says it plainly: see how a website, app or game works, then have AI build your own version.

The difference is how it organises the work. Instead of letting an LLM guess from a one-sentence description, Craft Anything splits understanding software and rebuilding it into two layers: the first observes the target and records evidence; the second uses a coding agent already signed in on your machine to write code. Between them sits a verification loop: the build is compared with the original, mismatches are listed, and the loop continues until it is close enough.

As of 05/11/2026, the project has 13,035 stars and 2,195 forks on GitHub, the latest release is v0.3.0 from 02/11/2026, and it is topping GitHub Trending for the day. The star-velocity figure (about +3.3 thousand per day) comes from third-party trackers, not GitHub. For a repository only 4–5 days old, that attention says nothing yet about long-term stability.

What Craft Anything is not

This is not a pure decompiler, and not a tool for copying code, logos, images or original text. It does not bypass DRM, get past login screens, or defeat anti-cheat. Nor does it replace a coding agent: to build, you need one already signed in on your own machine — Claude Code is the first supported choice — and Craft Anything runs your own unmodified claude program without touching your account.

The tool fits developers learning a product’s architecture and behaviour, sysadmins or DevOps engineers recreating an internal dashboard or tool whose source is lost, IT students wanting verifiable reverse-engineering practice, and Claude Code users wanting fast prototypes. It does not fit you if you need a pixel-perfect copy of a large commercial app, a production-ready result right away, or have no coding agent signed in. The responsible-use rule is explicit: use it only on software you own or are allowed to examine, and do not copy logos, images or text without confirmed permission.

How the Study → Build → Check → Refine loop works

The process packs into four steps. Study observes the target and records evidence — pages at multiple widths, code, files, how the software runs — as an evidence record with confidence, coverage and limitations. Build lets the coding agent build a new project in the language, framework or engine you request, or a sensible default. Games are rebuilt with Unity, Unreal or Godot; generated images and 3D models are opt-in and need your own fal.ai key. Check compares the build with the original: websites at three screen widths, games via their own self-test, apps via real runs. Refine and Ready: request changes in plain language, the loop continues until it is close enough, then open, preview or play the result.

The interface has two levels. Simple is the default: pick the target type, describe what you want, press Start, answer question cards, approve approval cards, and view the similarity score. Advanced is the full workbench: every tool via Ctrl/Cmd+K, plus functions, strings, pseudo-C, disassembly, hex, call graphs and the evidence ledger. “Just look inside” inspects without building.

flowchart TD
    Target["Target<br/>website / app / game / binary"]
    Study["Study Engine<br/>320 tools: 300 engine + AI/setup<br/>pure-Rust decoder / disassembler / decompiler"]
    Evidence["Evidence Ledger<br/>investigation.cany + capture/<br/>confidence / coverage / limitation"]
    Gate["Clean-room Gate<br/>default: refuses tools that read inside"]
    Builder["Builder<br/>coding agent on the user's machine<br/>Claude Code first; Codex not verified live"]
    Project["Generated Project<br/>app/ + craft.json"]
    Check["Check<br/>3 widths / game self-test / app runs<br/>results saved in checks/"]
    Decision{"Close enough?"}
    Refine["Refine<br/>requests in plain language"]
    Ready["Ready<br/>open / preview / play"]
    Inbox["Inbox<br/>open questions for the user"]
    Approval["Approval Cards<br/>gate before unseen command kinds"]
    Fal["fal.ai - opt-in<br/>generated images / 3D models"]
    Entry["Desktop app - egui<br/>CLI / MCP server<br/>same engine"]
    Inspect["Inspection<br/>No AI needed"]

    Target --> Study
    Study --> Evidence
    Evidence --> Gate
    Gate --> Builder
    Builder --> Project
    Project --> Check
    Check --> Decision
    Decision -- "not close enough" --> Refine
    Refine -.-> Builder
    Decision -- "close enough" --> Ready
    Entry --> Study
    Study -.-> Inspect
    Builder -.-> Inbox
    Builder -.-> Approval
    Fal -.-> Builder

The key point: Craft Anything reverses the usual order of trust — it does not trust the LLM, it trusts the evidence ledger. In my view, the quality bottleneck is not the figure of 320 tools, but how complete the evidence is, how capable Claude Code is, and how reliable the Check step is — it only compares surfaces, not business logic. A rebuild can score high on similarity and still get hidden behaviour wrong. That is why the project layout keeps capture/, checks/ and investigation.cany separate: you can verify what the agent saw and what it compared.

Clean-room vs Deep mode — the most important difference

A warning worth stating plainly: Clean-room is a rule about which tools are allowed and which are refused — not an OS sandbox. It does not isolate your computer, and the coding agent still acts with your user privileges. Do not use it to isolate malware. Clean-room lowers legal risk when you only observe a public surface, but it skips code and files inside, so complex rebuilds may be less accurate than in Deep mode.

Main components: engine, CLI, MCP server and desktop app

Under the interface sits a pure-Rust reverse-engineering engine with 320 tools for native programs, .NET, Java, Android, Apple, Electron/JavaScript, websites, firmware, packet captures, databases and game files. It has its own decoder, disassembler and decompiler, and runs without any outside program.

Every tool is both a CLI subcommand and an MCP tool, so an agent can study a target or run a whole rebuild without opening the app, and inspection needs no AI. The desktop app (egui), the CLI (craft-anything-cli) and the MCP server share the same engine; part of it runs in the browser as WebAssembly. Plugins include MCP servers and WASM components (the optional wasm-plugins option).

Each new project lives in Documents/Craft Anything (changeable in Settings → General), containing craft.json (request, target, status, history), capture/, app/, checks/, investigation.cany (evidence) and inbox/ (open questions). This structure makes a rebuild auditable, and lets you re-run Check or Refine without starting Study over.

Known technical limits (alpha)

Already working: desktop app (Simple and Advanced), CLI, MCP server, the Study → Build → Check → Refine loop with Claude Code, website checks at three widths, Unity/Unreal/Godot game rebuilds, Deep mode with Ghidra, and generated images and 3D models (opt-in, user’s own fal.ai key). Only partly there: building with API keys and other coding agents (built, not run live), behaviour checks for apps and games, and a few engine tools tested only on stand-ins. The Codex adapter exists but has not been verified on a real machine; among the other ACP agents, only Maki has been run live. GitHub Copilot works via the installed Copilot CLI, through ACP.

Not verified in this article — cross-checked against documentation only, not run hands-on: real rebuild quality, similarity scores, build times, and the Windows/macOS installers on a fresh machine.

System requirements and preparation

You need Rust 1.97 or newer, because a dependency requires it — update with rustup update before building. Installers ship for Windows, macOS, Linux and FreeBSD with each release. On Debian/Ubuntu, the desktop app needs these extra system libraries:

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

You also need a coding agent signed in on the machine — Claude Code is the first supported choice. Optional: Ghidra (Deep mode only) and a fal.ai key (generated images or 3D models only).

Method 1 — download a prebuilt release (v0.3.0)

Go to the official Releases page and pick the right asset for your OS and architecture. Windows has .msi or portable .zip files for x64, arm64 and x86; Linux has AppImage, .deb, .flatpak, .pkg.tar.zst, .rpm, .tar.gz for x86_64, aarch64 and riscv64; macOS and FreeBSD have their own builds too. Check the checksum in the release’s SHA256SUMS.txt before running it — a small step worth doing with alpha software.

Method 2 — build from source with Cargo

If you want the newest code from the main branch, want to audit it, or the prebuilt release lacks your architecture, build from source. The commands below are cross-checked against the official documentation; this article did not run them hands-on:

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

The first command runs the desktop app; the second installs the CLI as craft-anything-cli. Building from source requires Rust 1.97+ and the system libraries above, so a missing dependency usually fails here rather than at runtime.

Verify the install with craft-anything-cli doctor

After installing, run:

craft-anything-cli doctor

This command checks the install, coding agents and engines: doctor reports pass for the components that are ready, and points at any missing item. I will not invent details of output I have never seen — if doctor reports something unfamiliar, read its exact message and cross-check it against the project documentation. Two more commands: craft-anything-cli commands lists every tool by toolset; craft-anything-cli mcp serves those tools to an MCP client.

Your first rebuild

On the CLI, a website rebuild looks like this:

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

If the idea has no URL, use - as the target:

craft-anything-cli rebuild - "A snake game in Rust" --rounds 1

To continue or edit an existing project:

craft-anything-cli rebuild https://example.com "Make the header blue" --continue-in "<project folder>"
craft-anything-cli rebuild - "Add a contact form" --project-folder "<your folder>" --existing edit

Practical advice: make your first project your own website or a small game — not a large commercial app.

Common errors and how to fix them

These commands were verified against the official documentation only; this article does not claim a hands-on install test.

Strengths

The biggest strength is evidence-first: the result is an evidence record with confidence, coverage and limitations, browsable page by page with core_evidence_browse — not an unverifiable LLM answer. Inspection needs no AI, building uses your own agent, and the Check/Refine loop compares against the original instead of building once and stopping. It is open source and cross-platform, with CLI and MCP support for automation.

Weaknesses and caveats

The repo was 4–5 days old as of 05/11/2026, so alpha status is a fact, not a modest label. Behaviour checks for apps and games are still incomplete, a few tools have only been tested on stand-ins, and the claim “refine until it is close enough” is the project’s positioning — actual closeness varies by target, with no independent benchmark. Agent support is uneven: Claude Code leads, Codex has not been verified on a real machine, and among the other ACP agents only Maki has been run live. Rebuild quality depends heavily on the coding agent and the target’s difficulty.

Security and safe operation

Installing a dependency runs code on the user’s machine: npm runs install scripts by default, and Rust build scripts and Python source packages also run their own setup code. Craft Anything asks before running a command kind it has not seen before in the project — but if you press “always allow” for npm, every later npm command will run without asking, so use that only for projects whose dependencies you trust. When you need to install without running scripts, use npm install --ignore-scripts.

Clean-room is not a sandbox, so do not rely on it to isolate malware. Only run rebuilds on a separate machine or project, review dependencies before allowing them, and back up the project folder — especially app/ and craft.json — before a deep Refine. Rollback means returning to the app/ copy from an earlier check, or creating a new project from the same craft.json and capture/; no automatic rollback is documented, so a manual backup is the most practical line of defence.

Performance and scalability

No verified performance benchmark or build time exists, so this article makes no claim about speed or scale — only that the target’s size and complexity, the number of Refine rounds, and the coding agent’s performance are the factors that matter.

Comparison with alternatives in the same space

REA is an MCP analysis layer: an agent calls analysis tools and receives structured evidence. It analyses; it does not build. Craft Anything takes evidence as input and builds a working version — use REA when you only need to understand deeply, Craft Anything when you need a working build with a verification loop. Ghidra is strong at deep binary analysis, but slow, needs expertise, does not rebuild on its own, and has no automatic Check loop. Plain Claude Code or a bare LLM is flexible, but has no systematic Study, no evidence ledger, and no Check against the original.

Real-world use cases

Business and IT admins. Recreate an internal dashboard or tool whose source and documentation are lost — only when you own it or are allowed to — as a prototype to demo before a formal rewrite, or to record a legacy system’s behaviour as the spec for a migration.

Homelab and self-hosting. Build a similar version of a small web app you like, to self-host and customise for household needs, without copying copyrighted assets. Use the CLI and MCP to bring rebuilds into an automated homelab workflow — experimental projects only, while it is alpha.

AI workflows and DevOps. Use the CLI and MCP so an agent studies a target on its own and returns structured evidence for the design step; use the project folder (craft.json, checks/) as a reviewable artifact in code review. DevOps can quickly recreate an internal interface or monitoring tool for testing, but not in production while it is alpha.

Learning. IT students can use “Just look inside” and the Advanced workbench to study functions, strings and call graphs of a small app or game, then watch the agent rebuild it from evidence — learning by comparison, not by copying code.

Conclusion

Craft Anything fits people who already have Claude Code, want to learn and recreate a small website, app or game of their own, accept alpha status, and like a workflow with checkable evidence. It does not fit people who need to clone a commercial app, need production-ready results immediately, or have no coding agent signed in.

Next step: download v0.3.0 or build from source, run doctor, try rebuilding your own website or a small game, read checks/ to judge how close it got, and only then decide whether to bring it into a real workflow. Official links: storytold/craft-anything repo, Releases page and getartcraft.com.

Lessons learned

1. Evidence first, build second: a rebuild is trustworthy because it has a ledger you can check, not because an LLM says so.
2. Clean-room is a policy, not a sandbox: do not mistake the default mode for system isolation.
3. Rebuild quality equals agent quality plus evidence plus Refine rounds — 320 tools do not guarantee closeness.
4. Alpha means trying it first on a small project of your own; do not start with a large commercial app.
5. Approval cards and npm install --ignore-scripts are the practical lines of defence against dependencies running unfamiliar code.

Verification scope

Check date: 05/11/2026 (around 14:20 ICT). Sources: the README and GitHub API of storytold/craft-anything, the Releases page, and third-party trackers for trending and star velocity. Verified against official documentation: licence, language, stars, forks, creation and release dates, the four-step loop, Clean-room and Deep modes, 320 tools, the Rust 1.97+ requirement and Debian/Ubuntu dependencies, CLI commands, project structure, and the npm install-script warning. Default vs opt-in: Clean-room is the default; Deep mode, fal.ai and the WASM plugin are opt-in; the similarity score and three-width check are documented behaviour, not independently measured. The numbers are configuration, not benchmarks: 320 tools, 13,035 stars and v0.3.0 are metadata. Not tested: hands-on install, build and run, real rebuild quality, installers on a fresh machine, and the Codex adapter.

References

• Craft Anything — GitHub repository
• Craft Anything — Releases (v0.3.0)
• ArtCraft — getartcraft.com
• REA — reverse engineer applications with an AI agent (phamnam.me)