Source: Mayank A.'s LinkedIn post (2026-11-13) on storytold/craft-anything, from the team behind the PhotoCraft photo editor. Rust, MIT or Apache-2.0, early alpha (v0.6.1, 2026-11-12).
TL;DR
Craft Anything is a desktop app, CLI and MCP server that wraps a pure-Rust reverse-engineering engine (320 tools) around a coding agent. You give it a target (a website, app, game or file) and a request such as "recreate this site in Svelte". It runs a four-stage loop: Study the original, have the agent Build a new project, Check the build against the original and list mismatches, and refine until Ready. The interesting idea for agent engineering is not the cloning. It is that the original software is the test oracle, and that every inspection result is an evidence record with a confidence, a coverage figure and stated limits. Like R080 (AWS Emulator), the spec is a running system, and the acceptance test is how closely the build matches it.
The repo was about two weeks old at 33K stars as of 2026-11-15. The post's numbers check out: PhotoCraft has about 79K stars and Craft Anything crossed 31K.
How it works
One engine, three surfaces. All 320 tools are exposed as CLI commands and as MCP tools (craft-anything-cli mcp). Humans drive the same engine through an egui desktop app with a Simple view (four steps, approval cards, a similarity score) and an Advanced workbench (functions, strings, pseudo-C, disassembly, hex, call graphs, an evidence ledger and an "unknowns" panel). About 300 tools live in the engine and the rest in the AI and setup layers. The engine covers native binaries, .NET, Java, Android, Apple, Electron/JS, websites, firmware, packet captures, databases and game files, with its own decoders, disassembler and decompiler. Ghidra is optional. Inspection needs no LLM.
The loop.
Study. Capture the target: pages at every width, code, files, runtime behavior.
Build. A coding agent writes a new project in the requested stack, or a default.
Check. Compare against the original. Websites are checked at three screen widths, games with the game's own self-test, and apps by running them. Output is a list of what doesn't match yet and a similarity score.
Ready. Open or preview the result, or ask for changes and loop again.
The CLI form is rebuild <url|-> <request>, with --rounds to cap iterations and --existing to edit a prior build.
Two capability modes.
Clean room (default) works only from what a user can see: screenshots, visible text, measured layout, colors, fonts, menus, and optionally a window capture. Tools that read code, files or page source are refused, and the refusal says how to switch modes.
Deep unlocks everything for private use: disassembly, decompilation, reading a site's JavaScript.
The README is explicit that clean room is a policy about which tools are offered, not an OS sandbox. The coding agent still runs as the user with its own permissions, and a doc lists which Claude Code tools it can refuse.
Agents. Claude Code is the first-class builder: it runs the user's own claude binary under the user's own sign-in, and Craft Anything never touches the account. Codex has an adapter that hasn't been verified live. Copilot CLI, Grok Build and other agents (Gemini CLI, Qwen Code, opencode, goose and more) plug in through ACP, and only some have been run live. Analysis can use Anthropic, OpenAI, OpenRouter, xAI or local OpenAI-compatible models.
Durable project state. Each project is a folder: craft.json (request, target, status, history), capture/ (what was recorded), app/ (the build), checks/ (each comparison), investigation.cany/ (evidence) and inbox/ (open questions for the user). Large results come back as a summary first and are paged on demand.
What's transferable
The reference implementation as oracle. When a working system exists, diffing against it is a stronger acceptance test than tests the agent writes for itself. This is the same move as R080, but for UIs and behavior instead of API contracts. Checking at several viewports and using the target's own self-tests are cheap ways to widen coverage.
Evidence records, not answers. Each finding carries confidence, coverage and limitations, and there is a first-class list of unknowns. That makes "what we didn't look at" visible, which is the same coverage-ledger idea as the security tools in R073.
Capability modes as tool allowlists, honestly labeled. Refusing a class of tools is a real, cheap control on what the agent sees, and the refusal message teaches the user how to escalate. Calling it a policy rather than a sandbox is the right framing (compare R074 and R030: only an enforcement layer below every interface is a security boundary).
Questions as files. An
inbox/of open decisions turns ask-the-human moments into durable, reviewable state rather than chat interrupts.Summary-first, paged results. This keeps a 320-tool surface from flooding the context window.
Tradeoffs and failure modes
Similarity is not equivalence. A visual and behavioral match says nothing about authorization, race conditions, data integrity or business rules. The top comment on the post made this point: the interface clones in hours, but years of production fixes don't. Treat the similarity score as a UI fidelity metric, not a correctness one.
Clean-room leakage. Because clean room is only tool policy, an agent with shell access can still read source or fetch page JavaScript by other means. For a defensible clean-room claim you would need OS-level isolation plus logs showing what was read. Commenters flagged the same risk.
Legal exposure is the user's. The README limits use to software you own or may examine, says it never bypasses DRM, logins or anti-cheat, and tells the agent not to copy logos, photos or text. Deep mode decompilation can still create license and IP risk depending on jurisdiction and EULA.
Supply-chain and execution risk. Building runs package installs. The tool asks before each new kind of command and warns that "always allow" for npm trusts every install script. Commenters advised running it isolated, away from a personal dev environment.
Maturity. Early alpha. The loop works with Claude Code on websites, apps and games. Building with API keys and with other agents is implemented but not run live. Some tools are tested only against stand-ins. Star velocity is high, but the project is two weeks old.
Oracle drift. As with R080, a live target can change between Study and Check, so the capture needs a timestamp and a re-capture before comparing.
Review checklist (if you adopt the pattern)
Is the oracle pinned? Capture timestamped, re-captured before the final check.
Does the check measure behavior that matters (flows, states, errors), not only pixels?
Are unknowns and coverage reported next to the similarity score?
Is clean room enforced below the agent (container, network and filesystem limits), or only by tool allowlist? Is that documented?
Is there a read log that would survive an IP challenge?
Do package installs run in a disposable environment?
Is the target one you own or are licensed to examine?
Related entries
R080 AWS Emulator: the closest match. A replica built by agents and graded against the real service, with fidelity published as data.
R020 test oracles for agent-written code.
R073 security repos: coverage ledgers and disproving verifiers. Its anti-AI-reverse-engineering entry (BLA) is the defensive counterpart.
R074 and R030: why a tool policy is not a sandbox.
R052 Open Code Review, same poster.
R071 one tool surface exposed as CLI and MCP.
R028 and R040: findings stored with their evidence.
Sources
Mayank A., LinkedIn post, 2026-11-13
storytold/craft-anything README