A new tool clones phone apps to React Native using a screenshot-diffing loop

A new developer tool uses an iterative screenshot-comparison process to convert mobile app UIs into functional React Native code, inferring navigation and building on-device state management.

THE ANSWER UP FRONT

This tool is for React Native developers who need to quickly prototype or bootstrap a new application based on an existing mobile app's design. It's a strong starting point for UI-heavy projects where getting a functional, pixel-accurate shell is the first major hurdle. You should skip it if you need a full, backend-integrated production app out of the box. This is an accelerator, not a one-click solution. The bottom line: its iterative screenshot-diffing approach is a genuinely clever solution to the hard problem of reverse-engineering native UI, promising a higher fidelity output than typical generative tools.

METHODOLOGY

This v0 review is based exclusively on the founder's technical write-up published on dev.to on an unknown date, accessed on July 7, 2026. The tool itself is not named in the post. The analysis covers the developer's claims regarding the tool's core mechanics, including its screenshot-based generation, iterative diffing loop for UI refinement, navigation graph inference, and its focus on creating functional on-device logic. What is not covered is any independent performance testing, an evaluation of the generated code's quality or maintainability, or its behavior with highly complex or state-dependent applications. All features and capabilities described here are claims from the source article. This review will be updated if independent benchmarks or hands-on access becomes available.

WHAT IT DOES

Screenshot-based generation

The tool's fundamental input is a set of screenshots from a target iOS or Android application. Unlike web cloners that can parse the DOM and CSS, this tool operates on pixels alone. The developer notes this makes the source platform (iOS or Android) irrelevant, as the input is always just a collection of images. This approach bypasses the need for decompiling, SDKs, or any form of application introspection.

An iterative diffing loop

The core of the tool is not a single-pass generation step. Instead, it employs a feedback loop to refine its output. The process, as described by the founder, is:

1. Generate a React Native screen based on an input screenshot.
2. Render the generated screen and take a screenshot of its own output.
3. Compare its own screenshot with the original target screenshot.
4. Identify the differences in layout, color, and spacing.
5. Adjust the generated code to minimize the difference and repeat the loop.

This iterative process continues until the generated output visually matches the target. The developer claims this is the key to avoiding the slightly-off, uncanny valley effect common in AI-generated UIs, which they call "AI slop."

Navigation graph inference

To create a navigable app instead of a collection of static screens, the tool analyzes UI chrome across multiple screenshots. It infers the app's structure by recognizing common navigation patterns. A persistent bottom bar suggests a tab-based layout. A back chevron in a header implies a stack navigator. It also matches text labels, connecting a button labeled "Settings" to the screen with "Settings" in its header. This analysis produces a specification file (app-spec.json) that defines the navigation graph, which is then used to scaffold the app with Expo Router.

Functional on-device logic

The tool aims to produce more than a dead UI shell. It distinguishes between actions requiring a server and those that can run on-device. Backend-dependent features are stubbed out with TODO markers. On-device actions, like adding an item to a list or updating a local balance, are implemented. The developer states that data from these actions persists between sessions, creating a functional local application. To validate this, each generated clone includes a test script that drives the app headlessly to confirm features work as expected.

WHAT'S INTERESTING / WHAT'S NOT

The most interesting component is the screenshot-diffing loop. It's a pragmatic, verifiable method for achieving high-fidelity UI replication. Instead of relying on a model's single, often-flawed interpretation of an image, it creates a closed-loop system that measures its own error and corrects it. This is a significant step up from tools that produce a visually approximate but structurally incorrect first draft. The inclusion of an automated test suite with each clone is another strong signal. It shows a commitment to functional correctness, not just aesthetic similarity, which is a common failure point for similar tools.

What's not clear is the quality of the resulting code. The founder's post focuses entirely on the process and the functional output, but not the maintainability of the generated React Native components. Is the code idiomatic? Does it use a coherent state management pattern? Or is it a tangle of auto-generated styles and components that would require a full rewrite to extend? The developer is also upfront about its limitations: it does not generate a backend and it only approximates brand icons. Its ability to handle complex, conditional UI flows is admittedly a weak spot, which could be a major blocker for cloning anything beyond simple utility apps.

PRICING

Pricing information was not available in the source material as of July 7, 2026. The project appears to be in an early, pre-commercial stage.

VERDICT

For a React Native developer or team tasked with rebuilding an existing app, this tool appears to be a powerful accelerator. Its core innovation, the iterative diffing loop, directly addresses the most common complaint with UI generation tools: a lack of precision. By optimizing for a pixel-perfect match and building functional on-device state, it promises to deliver a V1 that is more than just a visual mock. However, its utility in a professional workflow is entirely dependent on the quality and maintainability of the code it generates, which remains an open question. It is a tool for starting a project, not finishing one.

WHAT WE'D TEST NEXT

A v2 review would require hands-on testing. First, we would run a complex, real-world application like Spendee or Todoist (mentioned in the post) through the process to evaluate the output against a known baseline. Second, we would perform a code quality review on the generated React Native project, assessing component structure, styling, and state management. Third, we would test its limits by feeding it screenshots with ambiguous navigation cues, complex animations, and heavy conditional logic to see where the inference engine fails. Finally, we would measure the end-to-end time from screenshots to a running, test-passing build to quantify its speed as a development accelerator.

The investor read

This tool targets the difficult but valuable native mobile development market, a space less saturated with AI-native tooling than the web. Its defensible technical kernel is the screenshot-diffing loop, a practical solution to the 'no DOM' problem on mobile. For investment, the key questions are scalability and code quality. Can the tool handle complex, enterprise-grade apps, or is it confined to simpler consumer apps? Is the generated code a true accelerator that professional teams can build on, or a throwaway prototype? The project's current status (unnamed, no pricing) suggests a very early, likely solo-founder stage. A successful demonstration on a complex app and a clear path to generating maintainable code would make it an interesting seed-stage investment or a prime acquisition target for players in the mobile development ecosystem like Expo or Microsoft (for React Native).