Rebuild any app and fix what its users hate: a hands-on guide to the Replica skill set

Jake Schincariol's Replica is eleven free, MIT-licensed Claude skills that take an app apart and put it back together as yours: one reverse-engineers the target, one rebuilds it, one tests it for bugs, and one reads what the app's users hate and turns it into your positioning. Created on October 3, 2026 and already past roughly 2,900 GitHub stars, it is the most complete answer yet to the vibe-coding question nobody asks out loud: what happens after the demo works. This guide installs the skill set, runs all eleven skills in order, and exercises the six standard-library Python tools that keep the whole thing honest.

• Replica is eleven free Claude skills (MIT license) by Jake Schincariol, published 2026-10-03, with roughly 2,900 GitHub stars in its first two weeks.
• Install as a Claude Code plugin (/plugin marketplace add Jakeschincariol/replica-skill then /plugin install replica-skill@replica-skill), copy the eleven replica-* folders into ~/.claude/skills/, or paste one SKILL.md into a chat.
• The pipeline runs recon → architect → design → build → backend → test → diff → entrepreneur → brand → launch → deploy, each skill reading the last one's output in a replica/ folder.
• Six standard-library Python tools, no network access: imgdiff.py, parity.py, reviews.py, contrast.py, sweep.py, listing.py — plus a test suite run with python3 -m unittest discover -s tests -v.
• In the README's worked example, recon maps 18 screens and 7 flows; diff scores the clone Features 86 and booking-page layout 91; entrepreneur reads 140 real reviews across the App Store, G2, Capterra, and Reddit.
• Clean-room by design: features and flows only — never code, logos, copy, or content. sweep.py blocks deploy until the original's name is gone, and the fine print says to check trademarks and talk to a lawyer before selling.

Vibe coding has a last-mile problem. Generating a working demo is easy now; shipping a finished product that real people will pay for — tested, on-parity with the thing it replaces, branded as yours, live on your domain — is still a weeks-long grind of unglamorous work. Replica attacks exactly that grind. It is not a code generator. It is a process: eleven Claude skills that walk you from "I like this app" to a deployed competitor with a launch angle, with a Python tool at every checkpoint to keep the agent honest.

Here is the honest pitch from the README: it rebuilds what an app does, never what it owns. Features and flows, clean-room style — not its code, logo, copy, or content. Everything below is real, taken from the project's README and repo. Clone the repo and follow along.

What you'll need

• Claude Code (recommended) or any Claude chat — the skills are slash commands, but any single SKILL.md also runs as a prompt mode
• Python 3.8 or newer — the six checker tools are standard-library only, nothing to pip install
• A target app you are allowed to study: its public pages, help center, pricing page, store listing — and your own account if you have one
• A project folder to build in; the skills keep their working files in a replica/ folder inside it

Step 1: Install the skill set

Three ways, pick one. Easiest is the Claude Code plugin route. Paste this into Claude:

https://github.com/Jakeschincariol/replica-skill

install skill

Or as a plugin, in Claude Code:

/plugin marketplace add Jakeschincariol/replica-skill
/plugin install replica-skill@replica-skill

Claude Code namespaces plugin skills, so installed this way they show up as /replica-skill:replica-recon and friends. If you want the plain /replica-recon form, clone and copy instead:

git clone https://github.com/Jakeschincariol/replica-skill.git
cp -r replica-skill/replica-* ~/.claude/skills/

Want the skills scoped to one project? Copy the same folders into your repo's .claude/skills/. No Claude Code at all? Paste any single SKILL.md at the top of a chat and it runs as a mode — you lose the Python tools, but the method works. The tools themselves need Python 3.8 or newer, and there is nothing to pip install.

Step 2: Run recon — reverse-engineer the target

/replica-recon studies the app you want to clone: screens, flows, components, data model — from public pages, screenshots, store listings, and your own account. What comes out is replica/recon.md plus a features.csv matrix. In the README's worked example (a scheduling app, the share-a-link-and-book-a-time kind), recon finds 18 screens and 7 flows — guest books a meeting, host sets availability, guest reschedules — plus the components and an inferred data model (users, event types, availability, bookings). It also marks things out of scope honestly: the app's partner marketplace is their network, not a feature, and says so.

Two guardrails worth knowing up front: it only reads what you are allowed to read — public pages and your own account, never behind someone else's login, never against a site's terms — and it never scrapes past a paywall. If your account's terms forbid building a competitor with it, the skill says so and sticks to public sources.

Step 3: Plan the stack with architect

/replica-architect reads the recon map and plans the stack, the database schema, and the API for your clone. In the example it picks Next.js, Postgres, Stripe, and Resend, writes the schema — including a constraint so two guests can never book the same slot — and orders the build: the booking flow end to end first, everything else after. This is the step most vibe-coded projects skip and most failed ones regret skipping.

Step 4: Rebuild the design system with design

/replica-design measures the screenshots into design tokens: colour roles, type scale, 8px spacing, the date picker and slot button specs — built with open icons, an open font, and your own words. Then it checks its own homework:

python3 replica-design/contrast.py replica/design/tokens.json

That runs WCAG contrast checks over your tokens, so the clone is accessible by construction rather than by apology. The output lives at replica/design/tokens.json for the build steps to consume.

Step 5: Build it screen by screen, then wire the backend

/replica-build rebuilds the app from the recon map: the shell first, then the core flow, then every screen with all its states, ticking off features.csv as it goes. Then /replica-backend adds the unglamorous essentials: sign up, Google Calendar through Google's own API with your keys, Stripe for paid bookings, reminder emails. The skills read each other's output — build consumes the design tokens, backend consumes the architecture — so the chain holds together.

Step 6: Test it for bugs

/replica-test writes a test plan from the flows, generates Playwright specs for the happy paths and the edge cases — time zones, a slot taken mid-booking, double submit — and logs bugs by severity until no S1 or S2 is open. The skill ships with test-plan.md and bug-report.md templates plus an e2e.example.spec.ts to start from. You can run the project's own tool tests the same way the author does:

python3 -m unittest discover -s tests -v

Step 7: Score yourself against the original with diff

This is Replica's most distinctive idea: a numeric parity score, not a vibe. Two tools:

python3 replica-diff/imgdiff.py original.png clone.png --out diff.png   # layout diff, ignores colour
python3 replica-diff/parity.py replica/features.csv                     # parity score + missing list

imgdiff.py reads PNGs with no libraries at all — pure standard-library code — turns both screenshots into edge maps, and compares where things are, so your new colours don't count against you. It reports which regions differ, in the original's pixels. parity.py weights must-, should-, and could-haves, counts partials as half, ignores what you deliberately left out and what you added — and refuses to call it shippable while must-haves are missing. In the worked example the clone scores Features 86 with all must-haves done, booking-page layout 91, and an honest missing list: round-robin for teams, the website embed.

Step 8: Read what the users hate with entrepreneur

/replica-entrepreneur is the skill that turns a clone into a business. It reads real reviews — in the example, 140 of them across the App Store, G2, Capterra, and Reddit — and the companion tool ranks the complaints:

python3 replica-entrepreneur/reviews.py replica/reviews.csv             # what users hate, ranked, linked

reviews.py drops every review without a link, so nothing is unverifiable; every quote it prints is copied from a row you gave it, with that row's URL; and themes with under three reviews or a single source are marked thin. The example's top complaints — per-seat price jumps, no text reminders, guests confused by time zones, each with counts and linked quotes — become a fix plan (flat pricing, SMS reminders, a time-zone confirm step) and a positioning angle: booking links for small teams that hate per-seat pricing. You can also run this skill on its own, on an app you are only thinking of cloning, as a cheap way to find out whether you should.

Step 9: Rebrand and sweep before you ship

/replica-brand names your version (with the trademark and domain checks to run), gives it a new palette, a logo brief, and a voice — then sweeps the codebase until nothing of the original is left:

python3 replica-brand/sweep.py . --avoid "Original App"                 # anything of the original left?

sweep.py finds the original's name, domain, and colours anywhere in your code, including inside identifiers like OriginalAppEmbed, and /replica-deploy will not ship until the sweep is clean. This is enforced, not suggested.

Step 10: Launch and deploy

/replica-launch writes the landing page around your angle, sets pricing against the original's public page, and lints the store listing:

python3 replica-launch/listing.py replica/launch/listing.json           # store limits + copycat checks

listing.py checks App Store and Google Play limits, ranking claims in the title, wasted keyword characters — and the original's name anywhere in your listing. Finally, /replica-deploy runs the preflight (tests, parity, sweep, listing), sets up production, hands you the DNS records for your domain, and ships it when you say go.

What you built

A complete pipeline, not just a codebase: a replica/ folder containing a recon map and feature matrix, an architecture doc and schema, design tokens with a passing contrast check, a rebuilt app wired to auth, calendar, payments, and email, a test plan with Playwright specs and a closed severity log, a parity score against the original, a review-mined fix plan and positioning angle, a clean rebrand verified by the sweep tool, and a linted launch package — deployed on your own domain. Every claim in the chain has a checker behind it: edge maps, weighted scores, linked quotes, byte-level sweeps.

Honest limitations

• No guarantee of a "perfect" clone. The README is blunt: results depend on complexity. A booking tool is weeks of work; a spreadsheet engine is not. /replica-recon sizes the job honestly before you start.
• "Clone any app" means features and flow — not the content, the network, or the licences the app owns. You can rebuild a music app's player, playlists, and sharing; you cannot clone its catalogue.
• Public sources only. The skills never scrape behind a login, never touch someone else's account, never get past a paywall. Complex apps with no public surface to study will starve the recon step.
• The legal responsibility is yours. The tooling is clean-room by design and the sweep blocks a dirty deploy, but the fine print says to run the trademark checks /replica-brand lists and talk to a lawyer before launch if money is on the line. It is not legal advice.
• You still need a capable model. Without Claude Code you can paste a SKILL.md into a chat, but you lose the Python tools — and with them the parity scores, the sweeps, and the listing checks that make the pipeline more than a prompt.