Skip to main content
skill CX Codex

replica-recon — Claude Code skill: map any app to clone it

replica-recon analyzes an app and builds a recon map: screen inventory, user flows, component list, data model and feature matrix. Works with public pages, screenshots, docs and your own account.

MIT 1,700 installs ★ 10,263 updated 2026-10-03

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Jakeschincariol/replica-skill --skill replica-recon -a claude-code
Open on GitHub

What replica-recon does

The skill creates three files in a replica/ folder: recon map (recon.md), feature matrix (features.csv) and a screenshot reference folder. This foundation matters — the rest of the Replica pack builds from it, and a weak recon map means a weak clone.

It works only with public sources and your own account. Never logs into someone else's account, never bypasses paywalls, never reads or saves app code or private API calls. If the service terms forbid using your account to build a competing product, the skill will switch to public sources only.

The workflow: define project scope (which app, which platform, which slice of features), build a sources table with URLs ranked by value (help center first, your account last), list every screen with its purpose and states (empty, loading, filled, error), trace user flows by goal, name every reused UI component, infer a data model with confidence levels, generate a feature matrix (priority, progress, notes), identify what cannot be cloned (licensed content, other people's data, regulated licenses). The skill then estimates project size and points you to /replica-architect.

What it helps with

  • map out screens and flows before starting to build
  • infer the data model by reading the interface
  • list features with priorities for the clone
  • identify hard parts: realtime sync, payments, integrations
  • estimate the scope and effort for a rebuild

Example prompts for the agent

  • Map Notion for cloning: pages, blocks, sharing, and permissions
  • Build a recon for Figma focused on the canvas and layers
  • Analyze an app from its App Store link: extract screens, flows and core features

How to install replica-recon

1Skills CLI (Vercel)

npx skills add Jakeschincariol/replica-skill --skill replica-recon -a claude-code

2Manually: put the files in place

~/.claude/skills/replica-recon/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/replica-recon/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about replica-recon

How do I install replica-recon in Claude Code?

Run npx skills add Jakeschincariol/replica-skill --skill replica-recon -a claude-code in your terminal, then open ~/.claude/skills/replica-recon/SKILL.md.

What does replica-recon do?

It studies an app from public sources and your account, then produces a recon map: screen list, user flows, UI components, inferred data model and feature matrix. This is the prep work before building a clone.

What sources does it use?

Help center, pricing page, changelog, App Store listing, walkthrough videos, marketing site, public API docs and your own account. It never logs into accounts that are not yours and never bypasses paywalls.

Source text

SKILL.md · MIT
---
name: replica-recon
description: >-
  Reverse-engineers any app into a recon map: screen inventory, user flows,
  component list, inferred data model and a feature matrix, from public pages,
  screenshots, app store listings, help docs and the user's own account. The
  first step of the Replica pack. Use when the user says "clone this app",
  "reverse engineer X", "how does X work", "map out X", "what screens does X
  have", "I want to build my own version of X", "copy this app", or pastes an
  app's URL or App Store link and wants to rebuild it.
---

# replica-recon

Everything else in the pack builds from what this skill writes. A bad recon
map means a bad clone, so take the time here.

Output goes in the user's project:

```
replica/recon.md        the recon map (template: recon-map.md in this folder)
replica/features.csv    the feature matrix (template: features.csv in this folder)
replica/screens/        reference screenshots of the original. Never shipped.
```

## The rules, before anything else

This skill rebuilds **functionality and UX patterns**, clean-room style. It
studies what the app does and how a user moves through it. It does not take
anything the app owns.

- **Public sources and the user's own account only.** Never log into an
  account that is not the user's, never ask for a password, never get past a
  paywall or a login by any trick.
- **Reading, not scraping.** No crawlers, no bulk downloads, no loops. If a
  browser tool is connected to the user's own browser, read pages at human
  speed with the user present.
- **No source code, no private APIs.** Do not read or save the app's
  JavaScript bundles, decompile its binary, or log its network calls to copy
  endpoints. Public API docs are fine to read.
- **Check the terms.** Some products' terms forbid using an account to build a
  competing product. If the user's account is under terms like that, say so
  and work from public sources only.
- **Screenshots are reference.** They live in `replica/screens/`, are used to
  compare layouts, and never go into the clone.

## Step 1: scope

Ask three things, or propose answers and get a yes:

1. **Which app, which platform.** Web, iOS, Android, desktop.
2. **Which slice.** "All of Notion" is not a project. "Notion's pages, blocks
   and sharing" is. Default to the core loop: the one flow users pay for.
3. **Who it is for.** The user's own business, a niche, a product to sell.

## Step 2: list the sources

Build a sources table first, with a URL on every row. In order of value:

| source | what it gives you |
| --- | --- |
| help center / docs | the most complete feature list there is, and the settings |
| pricing page | which features matter (they gate them) |
| changelog | what was added recently, what the team thinks is important |
| app store listing | screenshots of every key screen, the pitch, ratings |
| public walkthrough videos | real flows, click by click |
| marketing site | positioning, the core loop in their words |
| the user's own account | the real thing, every state, driven by the user |
| public API docs | the data model, almost for free |

## Step 3: screen inventory

One row per screen. IDs are stable: S01, S02... Every other file refers to them.

`ID | screen | route or how you get there | purpose | key components | states seen`

States matter: empty, loading, filled, error, permission denied, mobile. An
empty state you did not record is an empty state you will not build.

## Step 4: user flows

F01, F02... Each one is a goal and the screens it passes through:

```
F01 Guest books a meeting
    S07 booking page -> S08 pick a time -> S09 details form -> S10 confirmed
    edge: no slots this week, time zone differs, slot taken while filling the form
```

Count the clicks on the happy path. It becomes the number to beat.

## Step 5: components

Every repeated UI part: buttons, inputs, date pickers, modals, tables, toasts,
nav. Name, variants, states, which screens use it. This becomes
replica-design's component list.

## Step 6: inferred data model

Entities, fields and relationships, each with its evidence and a confidence:

```
Booking  id, event_type_id, start_at, end_at, guest_name, guest_email,
         status (confirmed | cancelled | rescheduled), answers (json)
         evidence: S09 form fields, S10 confirmation, help article "Cancel a booking"
         confidence: high
```

Mark guesses as guesses. replica-architect turns this into a real schema.

## Step 7: feature matrix

Write `replica/features.csv` (columns: feature, area, priority, original,
clone, notes). Priority is must / should / could. `clone` starts at `no` for
every row and gets filled in during the build. replica-diff scores it.

## Step 8: what cannot be cloned

List it honestly, as `skip` rows with a reason: licensed content (a music
catalogue, a stock library), the network and its users, data the app owns,
partner deals, hardware, regulated licences (banking, health). "Clone any
app" means the features and the flow, not what the app owns.

## Step 9: size it

Screens, flows, entities, and the hard parts (realtime, sync, payments,
calendar or email integrations, offline). Give a size: S (a weekend), M (a
few weeks), L (a quarter), XL (rescope it). No promises of a perfect clone.

## Output

`replica/recon.md` and `replica/features.csv`, then a five-line summary: the
core loop, screen and flow counts, the three hardest parts, what is out of
scope, and the next step: `/replica-architect`.

© Jakeschincariol · MIT · Jakeschincariol/replica-skill

Similar skills

All skills for Frontend and UI →

From the same set11

The whole set →
replica-backend Builds the backend of an app clone: auth, database migrations and access rules, Stripe payments, email and background jobs. Reads replica/architecture.md and keeps a checklist in replica/backend.md. CX Codex +1 1,600installs replica-deploy replica-deploy prepares an app clone for release on your own domain with preflight checks, production setup and DNS guidance. Use it before going live. CX Codex +1 1,600installs replica-brand replica-brand names app clones, sets up contrast-checked palettes, writes logo briefs, and sweeps original brand remnants from code. CX Codex +1 1,600installs replica-architect replica-architect plans the stack, database schema and API routes for an app clone, working from the recon map replica-recon produced. Useful once recon is done and you need a build plan. CX Codex +1 1,600installs replica-launch replica-launch is a Claude Code skill that prepares launch materials for an app clone: a landing page, pricing, and App Store and Google Play listings. It activates for requests about launch copy, pricing, or a launch plan. CX Codex +1 1,600installs replica-build replica-build rebuilds an app screen by screen from the recon map: shell first, then the core flow, then every screen with all its states. Useful when you need to reproduce a product in your own code. CX Codex +1 1,600installs replica-diff replica-diff — a skill for Claude Code, Codex, Cursor and other platforms that scores feature parity between a clone and its original, then diffs screen layouts while ignoring colour. Outputs what is missing, ordered by build priority. CX Codex +1 1,600installs replica-design replica-design is a Claude Code skill that rebuilds an app clone’s design system from screenshots as tokens, styles, and component specs. It supports screenshot-based interface reconstruction. CX Codex +1 1,600installs

Project sponsors

Companies that keep this analytics open