Replica Skill: Eleven Skills That Turn Claude into a Full Development Team for Cloning Any App

From “I Want to Build an App Like…” to Actual Launch

How many times have you used an app, admired its idea, and felt you could build it better or differently? The problem is not the idea, but the execution. Analyzing the original app, understanding its components, designing a database, building the interface, writing tests, then launching it. This process takes months and requires a team.

Replica Skill by Jake Schincariol (OpusJake) attempts to compress this process into a series of commands inside Claude. The idea: instead of starting from scratch, you start by analyzing an existing app, then build a functionally identical clone (clean-room), but with a new identity and fewer flaws.

🔗 Official Repository: github.com/Jakeschincariol/replica-skill 🔗 Official Website: opusjake.ai

What Is Replica Skill?

It is eleven skills that work with Claude Code or OpenCode, licensed under MIT, and completely free. No signup, no API key, and no connection to any external service. Everything runs locally using standard Python tools.

The core idea: do not copy the code, copy the function. The skills study what the app does and how users move through it, then write everything fresh. No source code is copied, no logos, no copy, and no private APIs. This is called clean-room reimplementation.

The Eleven Skills

The process follows a logical sequence, from analysis to launch:

Command	Function
`/replica-recon`	Reverse-engineers the app: screens, flows, components, data model. From public pages, screenshots, store listings, and your own account.
`/replica-architect`	Plans the tech stack: framework, database, API.
`/replica-design`	Rebuilds the design system: colors, type, spacing, components. As tokens, with your own assets.
`/replica-build`	Builds the app screen by screen from the recon map.
`/replica-backend`	Auth, database, payments, and integrations.
`/replica-test`	Clicks through every flow and tests it for bugs.
`/replica-diff`	Compares your clone against the original: a parity score and what is missing.
`/replica-entrepreneur`	Reads what the app’s users hate in real reviews and turns it into fixes and a positioning angle.
`/replica-brand`	Names and rebrands your version so it is yours.
`/replica-launch`	Landing page, pricing, and App Store listing.
`/replica-deploy`	Ships it live on your own domain.

How It Works: A Practical Example

Imagine you want to build a clone of a scheduling app. The workflow would be:

/replica-recon: By passing the app’s URL, the skill reads the help center, pricing page, and store listing. Output: a recon.md file describing 18 screens, 7 flows (guest books a meeting, host sets availability, guest reschedules…), an inferred data model (users, event types, availability, bookings), and a features.csv matrix.
/replica-architect: You choose Next.js, Postgres, and Stripe. It writes the schema, with a constraint so two guests can never book the same slot.
/replica-design: It measures screenshots into design tokens: color roles, type scale, 8px spacing, date picker specs.
/replica-build: It builds the shell, then the booking flow, then every screen with all its states.
/replica-backend: It adds sign-up, Google Calendar integration, Stripe for paid bookings, and reminder emails.
/replica-test: It writes a test plan from the 7 flows and Playwright specs for happy paths and edge cases (time zones, a slot taken mid-booking, double submit).
/replica-diff: It gives you a score: features 86, all must-haves done, booking page layout 91. Missing: round-robin for teams, the website embed.
/replica-entrepreneur: It reads 140 real reviews across App Store, G2, Capterra, and Reddit. Top complaints: per-seat price jumps, no text reminders, guests confused by time zones. Fix plan: flat pricing, SMS reminders, a time zone confirm step.
/replica-brand: It names it (with 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.
/replica-launch: It writes the landing page around the angle, sets pricing against the original’s public page, and lints the store listing.
/replica-deploy: It runs the preflight (tests, parity, sweep, listing), sets up production, gives you the DNS records for your domain, and ships it when you say go.

The Six Tools (Python)

The project includes six Python tools that work offline:

imgdiff.py: Compares two screenshots and identifies differing regions, ignoring color.
parity.py: Calculates the parity score between your clone and the original and identifies missing features.
reviews.py: Analyzes user reviews and extracts recurring complaints with source links.
contrast.py: Checks design color contrast against WCAG standards.
sweep.py: Searches the codebase for any trace of the original app’s name, domain, or colors.
listing.py: Checks the app store listing (limits, keywords, claims).

Seriousness and Realism

The project is not a magic promise. The developer himself states in the fine print that “cloning any app” means features and flows, not content, network, or licenses. You can rebuild a music app’s player and playlists, but you cannot clone its catalogue. Results also depend on the app’s complexity: a booking tool takes weeks, a spreadsheet engine does not.

Most importantly: the project does not provide legal advice. You must run trademark checks, read the terms of anything you used, and talk to a lawyer before launch if there is money on the line.

Summary

Replica Skill is an ambitious framework that uses Claude to turn the process of “building a clone of an app” from a months-long project into an organized sequence of commands. It is not a replacement for technical understanding or legal advice, but it offers an organized starting point for anyone who wants to build a product that competes with an existing app, focusing on what users hate about the original. Being open source and free (MIT), it is worth exploring by developers and entrepreneurs alike.