← Back to list
📊

replica-recon Checked

Reverse-engineers any app into a recon map: screen inventory, user flows, component list, inferre…
📊 Data & Analytics skills By Jakeschincariol Version v1.0.0 Added 2026-10-12 Updated 2026-10-12 Source ↗
9.2Overall rating
0Views
0Downloads
1.9kStars

Installation

🤖 Install via AI

Copy the prompt below and send it to your AI assistant (e.g. Claude Code) — it will follow the instructions and install automatically.

Install the "replica-recon" skill by following the instructions at https://skill123.me/install/replica-recon.
⌨️ Command line install

Run in your terminal — downloads and installs to ~/.claude/skills/.

curl -fsSL https://skill123.me/install/replica-recon.sh | bash
📦 Download ZIP

Download the zip and extract it into your skills directory (e.g. ~/.claude/skills/), then restart your session.

⬇ Download v1.0.0 · 4 KB
📊 Static rating
9.2/10
Trigger
8.0
Structure
8.0
Workflow
9.6
Content
10.0
Engineering
10.0
Security
10.0

Six-dimension rubric with reviewer rationale.

View scorecard ↓
🛡 Dynamic test
—

Not live-tested yet — this skill is rated on static analysis only.

About this skill

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.

Documentation

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:

View full documentation

| 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.

Score breakdown

Trigger
8.0
What (reverse-engineer any app into a recon map, with output enumeration) and When (eight quoted phrasings including the indirect 'I want to build my own version of X' and the paste-a-URL case, plus 'first step of the Replica pack') are clear; good synonym spread (clone/reverse engineer/map out/copy); no explicit When-Not but scope rules in body compensate.
Structure
8.0
135-line SKILL.md plus two fill-in templates; templates at skill root rather than assets/ (role mixing); no redundant docs; template usage clearly signposted.
Workflow
9.6
Nine ordered steps with the strongest guards in the suite (public sources and own account only, no scraping, no source code or private APIs, ToS check, paywall prohibition); Step 1 requires user sign-off on scope; verification discipline is built in (evidence plus confidence per entity, 'mark guesses as guesses', stable screen IDs, honest skip rows and sizing with no promises), though no automated check exists at this stage.
Content
10.0
Tight imperative prose throughout; flow and data-model example blocks directly copyable; sources table with concrete value ordering.
Engineering
10.0
Valid frontmatter; no scripts; both referenced templates present in the folder; next-stage /replica-architect exists in the family; output paths consistent with what later stages read.
Security
10.0
Capability manifest: reads public web pages, app store listings, help docs and the user's own account (all declared); writes replica/recon.md, features.csv and a screenshots folder in the user's project; no scripts, no network commands, no credential access (explicitly never asks for a password), no persistence. Capabilities match declared scope; rules actively prevent ToS violations and IP theft.
Entry stage of the replica-* suite: reverse-engineer an app into a recon map (screen inventory, flows, components, inferred data model with evidence and confidence, feature matrix, honest out-of-scope list, sizing) from public sources and the user's own account, using two bundled templates (recon-map.md, features.csv). The access-ethics guard rails are the strongest of the pack: own account only, never bypass paywalls or logins, no scraping or bulk downloads, no JS bundles or decompiled binaries or endpoint sniffing, explicit ToS check for competing-product clauses, screenshots kept as reference and never shipped. Same structural nit: templates at skill root instead of assets/.