Inside storytold/craft-anything: Architecture & Production Teardown — How Does It Work in Production?
TL;DR: Craft Anything is an open-source, pure-Rust reverse-engineering and AI-generation engine that autonomously inspects existing software—websites, desktop apps, games, and binaries—and rebuilds them using local coding agents. By combining 320 built-in inspection tools with native Model Context Protocol (MCP) support, it bridges the gap between deep systems analysis and automated code generation, providing platform engineers with a high-performance, clean-room environment to deconstruct and clone architectures without relying on opaque managed cloud services.
What Is Inside storytold/craft-anything: Architecture & Production Teardown & Why Is It Blowing Up?
In our architectural evaluation of emerging developer tools, we rarely see systems that successfully merge low-level binary analysis with high-level generative AI. The repository storytold/craft-anything has recently surged on Trendshift (amassing over 33.7k stars and 6.8k forks, as noted on its repository readme), precisely because it solves a notoriously difficult engineering problem: deterministic, evidence-based software recreation.
Historically, reverse-engineering an application or cloning a frontend required a fragmented toolchain—network sniffers, DOM inspectors, decompilers, and manual transcription. Craft Anything unifies this into a single, pure-Rust engine. You point it at a target (a URL, a compiled game, a mobile app), describe what you want to build, and the engine orchestrates a four-step pipeline: Study (inspecting the original), Build (driving a coding agent to write the code), Check (comparing the build against the original), and Ready (refining the output).
What makes this repository particularly fascinating for systems engineers is its strict adherence to operational boundaries. By default, it operates in a Clean room mode. It does not read the target's source code, internal files, or page source. Instead, it relies purely on observable outputs—screenshots, measured layouts, visible text, and window captures. If deeper inspection is required, engineers can toggle Deep mode, which unleashes built-in decoders, disassemblers, decompilers, and even integrates with Ghidra if installed on the host machine.
Furthermore, Craft Anything does not attempt to be its own Large Language Model (LLM). Instead, it acts as a highly advanced tooling harness for existing coding agents. It natively supports Claude Code (running your unmodified claude binary), GitHub Copilot (via ACP), and Grok Build (via grok agent stdio). Because every one of its 320 inspection tools is exposed as a Model Context Protocol (MCP) tool, it is entirely agent-ready.
Real-World Field Use Cases: Where This Moves the Needle in the Field
To understand why platform teams are adopting this tool, we must look at how it behaves under production constraints. Here are three concrete field use cases demonstrating how Craft Anything integrates into modern engineering stacks.
1. Developer Platform Integration: Embedding into CI/CD and Microservice Pipelines
- The Everyday Problem: Enterprise teams frequently need to migrate legacy monolithic interfaces or recreate third-party integrations. Doing this manually requires extensive discovery phases, leading to bottlenecks in CI/CD pipelines where developers wait weeks for legacy system documentation.
- How It Works in Practice: Platform engineers can integrate Craft Anything directly into their automated pipelines using its headless CLI. By executing
craft-anything-cli rebuild https://internal-legacy-app.local "Recreate this dashboard in React", the engine studies the live legacy application. Because Craft Anything exposes its capabilities via MCP, teams utilizing enterprise agent frameworks—such as the Google ADK (Agent Development Kit)—can register Craft Anything as an MCP tool. An ADK LlmAgent orchestrating a Graph Workflow can dynamically trigger Craft Anything to inspect a failing microservice endpoint, gather evidence, and propose a rebuilt service.
- The Tangible Impact: This drastically reduces the discovery and scaffolding phases of legacy migration. By embedding the engine into the developer platform, teams achieve automated, evidence-backed code generation that is continuously checked against the original target's behavior.
2. Concurrency & Memory Footprint: High-Throughput Security Auditing
- The Everyday Problem: Security teams and reverse engineers often need to analyze hundreds of binaries, packet captures, or firmware images. Traditional tools (often written in Python or Java) suffer from high memory overhead, garbage collection pauses, and poor concurrency, leading to unacceptable P99 latencies under load.
- How It Works in Practice: Craft Anything is written in pure Rust. Its internal decoders, disassemblers, and decompilers operate without external dependencies (unless Ghidra is explicitly invoked in Deep mode). When processing massive game files or complex .NET/Java/Android binaries, the Rust engine leverages zero-cost abstractions and fearless concurrency. Engineers can run the engine in Deep mode (
--deep) across a cluster of machines to batch-process files.
- The Tangible Impact: The memory footprint remains minimal and predictable. P99 latency during the "Study" phase is strictly bound by CPU and I/O, not by runtime garbage collection. This allows security teams to scale their inspection workloads efficiently without over-provisioning cloud compute resources.
3. Build-vs-Buy Adoption Verdict: Operational Trade-offs Against Managed Cloud Alternatives
- The Everyday Problem: Organizations looking to leverage AI for software analysis often default to managed cloud services. However, sending proprietary binaries, internal network packet captures, or pre-release game files to a third-party cloud API introduces severe data privacy and compliance risks.
- How It Works in Practice: Craft Anything provides a compelling "Build" (or rather, "Self-Host") alternative. Because the engine runs entirely locally, and the AI integration relies on your own installed CLI tools (like
claude or copilot), the telemetry and data flow are entirely within your control. You authenticate your agents locally, and Craft Anything never sees or handles your account credentials.
- The Tangible Impact: Organizations bypass the compliance hurdles associated with managed cloud sandboxes. They achieve enterprise-grade reverse engineering and AI code generation while maintaining strict data sovereignty, resulting in significant operational cost savings and reduced legal friction.
Under the Hood: Architecture & Design Choices
When we inspect the production topology of Craft Anything, the architectural thesis is clear: build a monolithic, highly optimized inspection engine in Rust, and decouple the AI reasoning layer entirely.
The core of the system is a pure-Rust reverse-engineering engine containing 320 distinct tools (300 residing directly in the engine, with the remaining 20 handling AI and setup layers). This engine is capable of parsing native programs, .NET, Java, Android, Apple binaries, Electron/JavaScript apps, websites, firmware, packet captures, databases, and game files.
Architecturally, the system is divided into three primary interfaces driven by the same underlying engine:
- The Desktop App: Built using
egui, an immediate mode GUI library in Rust, ensuring high framerates and low latency.
- The CLI: A headless interface (
craft-anything-cli) designed for CI/CD integration and terminal-based workflows.
- The MCP Server: A critical design choice. By serving its tools via the Model Context Protocol (
craft-anything-cli mcp), the engine transforms from a standalone application into a modular backend that any modern AI agent can consume.
The execution pipeline relies heavily on the generation of "evidence records." When the engine studies a target, it does not just pass raw text to the LLM. It generates structured evidence with attached confidence scores, coverage metrics, and limitations. For large datasets, the engine returns a summary first, allowing the agent to page through the data using the core_evidence_browse command.
Here is a visual representation of the internal architecture and execution pipeline:
flowchart LR
subgraph TargetEnvironment["Target Environment"]
T1[Websites / Apps]
T2[Binaries / Games]
T3[Packet Captures]
end
subgraph CraftAnythingEngine["Pure Rust Engine"]
direction TB
I1[Clean Room Mode<br/>Visuals, Layouts, Public Data]
I2[Deep Mode<br/>Decoders, Disassembler, Ghidra]
T1 --> I1
T2 --> I2
T3 --> I2
I1 --> ER[Evidence Records<br/>Confidence & Coverage]
I2 --> ER
end
subgraph InterfacesOrchestration["Interfaces & Orchestration"]
CLI[craft-anything-cli]
GUI[egui Desktop App]
MCP[MCP Server]
ER --> CLI
ER --> GUI
ER --> MCP
end
subgraph ExternalAiAgents["External AI Agents"]
A1[Claude Code]
A2[GitHub Copilot / Grok]
ADK[Google ADK Agent]
MCP <--> A1
MCP <--> A2
MCP <--> ADK
end
subgraph Output
O1[app/ Generated Project]
O2[checks/ Comparisons]
A1 --> O1
A1 --> O2
end
This decoupled design ensures that as AI models evolve, the Craft Anything engine remains relevant. It acts as the sensory organ and the verification loop, while the external agent acts as the brain.
Hands-On Quickstart & Code Walkthrough
Deploying Craft Anything requires a modern Rust toolchain. According to the official release notes, the engine has a strict dependency requirement: Rust 1.97 or newer. You will need to run rustup update to ensure compliance.
If you are deploying the desktop application on a Debian or Ubuntu environment, the egui framework requires several system-level graphics and windowing libraries.
1. System Dependencies & Installation
First, install the required Linux packages:
sudo apt-get install libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libgtk-3-dev
Next, clone the repository and compile the binaries. The project is structured as a Cargo workspace containing both the desktop app and the CLI.
git clone https://github.com/storytold/craft-anything && cd craft-anything
# Build and run the desktop app
cargo run --release -p craft-anything
# Install the CLI globally as `craft-anything-cli`
cargo install --path apps/craft-anything-cli
# Verify the installation, coding agents, and engines
craft-anything-cli doctor
The doctor command is crucial here; it verifies that your local coding agents (like claude or grok) are properly authenticated and accessible in your system's PATH.
2. Rebuilding a Target via CLI
Once installed, you can initiate the rebuild process directly from the terminal. The CLI will prompt you for decisions when necessary.
# Recreate a website from a URL
craft-anything-cli rebuild https://example.com "Recreate this website"
# Generate a project from scratch without a specific URL target
craft-anything-cli rebuild - "A snake game in Rust" --rounds 1
# Refine an existing generation
craft-anything-cli rebuild https://example.com "Make the header blue" --continue-in " "
3. Understanding the Project Structure
By default, new projects are generated in Documents/Craft Anything. When you inspect a generated project folder, you will find a highly structured state directory:
craft.json: The core state file containing the request, target, status, and history.
capture/: The raw data recorded from the target during the "Study" phase.
app/: The actual generated source code of the new project.
checks/: The diffs and comparisons against the original target.
investigation.cany/: The structured evidence records used by the AI.
inbox/: Open tasks and pending approvals.
To expose the engine's 320 tools to an external MCP client (such as a custom Google ADK workflow), you simply run:
craft-anything-cli mcp
My Honest Verdict: Where It Fits in Your Stack (Pros & Trade-offs)
In our architectural evaluation, Craft Anything represents a paradigm shift in how we approach software analysis and generation. However, like any bleeding-edge system, it comes with distinct engineering trade-offs.
The Strengths
- Uncompromising Performance: Writing a reverse-engineering engine with 320 tools in pure Rust is a monumental task. The result is a system that is memory-safe, highly concurrent, and free from the dependency hell often associated with Python-based analysis tools.
- Agent Agnosticism via MCP: By refusing to hardcode a specific LLM API and instead relying on local CLI agents (Claude, Copilot, Grok) and the Model Context Protocol, the tool future-proofs itself. It integrates seamlessly into enterprise agent frameworks like Google ADK.
- Clean Room by Default: The strict separation between observable behavior (Clean Room) and internal logic (Deep mode) provides legal and operational safety nets for teams reverse-engineering third-party systems.
- Evidence-Based Generation: Unlike standard code generators that hallucinate based on a prompt, Craft Anything forces the agent to verify its output against the
capture/ data, storing the results in the checks/ directory.
The Trade-offs & Limitations
- Bleeding-Edge Rust Requirement: The hard requirement for Rust 1.97 or newer is exceptionally aggressive. For enterprise teams running stable or LTS toolchains, updating to this version may require overriding strict internal CI/CD policies.
- Heavy Linux GUI Dependencies: While the CLI is portable, running the
egui desktop app on Linux requires a substantial list of X11 and Wayland development headers (libxkbcommon-dev, libwayland-dev, etc.). In headless containerized environments, this requires careful Dockerfile optimization if you intend to run the GUI via X11 forwarding.
- Bring-Your-Own-Agent Complexity: Because Craft Anything does not handle API keys directly, you are responsible for installing, authenticating, and maintaining the underlying agent CLIs (e.g., Anthropic's
claude npm package). If your local agent's session expires, the build pipeline will halt.
Final Verdict: Craft Anything is not a toy; it is a serious piece of systems engineering. If your team is building developer platforms, conducting security audits, or migrating legacy systems, the ability to programmatically study and clone software architectures using a pure-Rust MCP server is invaluable. It shifts the paradigm from "prompting an LLM to write code" to "deploying an autonomous engine to reverse-engineer and verify systems." For teams willing to manage the local agent dependencies and the bleeding-edge Rust toolchain, it is a highly recommended addition to the platform engineering stack.