⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.0

replica-architect

jakeschincariol@jakeschincariol⭐ 9.4k stars· last commit 1mo ago· 23 open issues

>-

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 9.4k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

The Replica skill

Eleven Claude skills that clone any app. Free, MIT, no signup, no API key, nothing to connect.

One reverse-engineers the app you want to clone. One rebuilds it. One tests it for bugs. And one is the Entrepreneur: it reads what the app's users hate and fixes it in yours, so you have an app you can sell.

In between, the others plan the stack and the database, rebuild the design system, wire up auth and payments, score your clone against the original, give it a name and a brand of its own, write the landing page and the store listing, and put it live on your domain.

It rebuilds what an app does, never what it owns. Features and flows, clean-room style. Not its code, its logo, its copy or its content. The fine print is at the bottom, and the skills enforce it.

Install

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 as a plugin they show up as /replica-skill:replica-recon and so on. Copy the folders instead if you want plain /replica-recon:

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

Project-local instead of global: 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 need Python 3.8 or newer. Nothing to pip install.

The eleven

commandwhat it does
/replica-reconReverse-engineers any app: screens, flows, components, data model. From public pages, screenshots, store listings and your own account.
/replica-architectPlans the stack, database schema and API for your clone.
/replica-designRebuilds the design system: colours, type, spacing, components. As tokens, with your own assets.
/replica-buildRebuilds the app screen by screen from the recon map.
/replica-backendAuth, database, payments and integrations.
/replica-testClicks through every flow and tests it for bugs.
/replica-diffCompares your clone against the original. A parity score and what is missing.
/replica-entrepreneurReads what the app's users hate in real reviews and turns it into fixes and a positioning angle.
/replica-brandNames and rebrands your version so it is yours.
/replica-launchLanding page, pricing and App Store listing.
/replica-deployShips it live on your own domain.

How to use it

Run them in order. Each one reads what the last one wrote, in a replica/ folder in your project.

recon -> architect -> design -> build -> backend -> test -> diff -> entrepreneur -> brand -> launch -> deploy

An example: cloning a scheduling app, the kind where you share a link and people book a time with you.

  1. /replica-recon with the app's URL. It reads the help center, the pricing page, the store listing and public walkthroughs, and you click through your own account with it. Out comes replica/recon.md: 18 screens, 7 flows (guest books a meeting, host sets availability, guest reschedules...), the components, an inferred data model (users, event types, availability, bookings) and features.csv. The partner marketplace is marked out of scope: that is their network, not a feature.
  2. /replica-architect picks Next.js, Postgres, Stripe and Resend, writes the schema (with a constraint so two guests can never book the same slot) and orders the build: the booking flow end to end first.
  3. /replica-design measures the screenshots into tokens: colour roles, type scale, 8px spacing, the date picker and slot button specs. Open icons, an open font, your own words.
  4. /replica-build builds the shell, then the booking flow, then every screen with all its states, ticking off features.csv as it goes.
  5. /replica-backend adds sign up, Google Calendar through Google's own API with your keys, Stripe for paid bookings, reminder emails.
  6. /replica-test writes a test plan from the 7 flows, Playwright specs for the happy paths and edge cases (time zones, a slot taken mid-booking, double submit), and logs bugs by severity until no S1 or S2 is open.
  7. /replica-diff scores it. Features 86, all must-haves done, booking page layout 91. Missing: round-robin for teams, the website embed.
  8. /replica-entrepreneur reads 140 real reviews across the App Store, G2, Capterra and Reddit. Top complaints: per-seat price jumps, no text reminders, guests confused by time zones. Each with counts and linked quotes. Fix plan: flat pricing, SMS reminders, a time zone confirm step. Angle: booking links for small teams that hate per-seat pricing.
  9. /replica-brand names it (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.
  10. /replica-launch writes the landing page around the angle, sets pricing against the original's public page, and lints the store listing.
  11. /replica-deploy 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.

You can also run any one on its own. /replica-entrepreneur on an app you are only thinking about cloning is a good way to find out if you should.

The tools

Six of them, all standard-library Python. None touch the network.

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
python3 replica-entrepreneur/reviews.py replica/reviews.csv             # what users hate, ranked, linked
python3 replica-design/contrast.py replica/design/tokens.json           # WCAG contrast on your tokens
python3 replica-brand/sweep.py . --avoid "Original App"                 # anything of the original left?
python3 replica-launch/listing.py replica/launch/listing.json           # store limits + copycat checks

imgdiff.py reads PNGs with no libraries, turns both screenshots into edge maps and compares where things are, so your new colours do not count against you. It tells you which regions differ, in the original's pixels.

parity.py weights must, should and could, counts partial as half, and never scores what you left out on purpose or what you added. Missing must-haves means not shippable, and it says so.

reviews.py drops every review without a link. Every quote it prints is copied from a row you gave it, with that row's URL. Themes with under three reviews or one source are marked thin.

sweep.py finds the original's name, domain and colours anywhere in your code, including inside identifiers like OriginalAppEmbed, and blocks the deploy until it is clean.

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.

python3 -m unittest discover -s tests -v

Fine print

It rebuilds functionality and UX patterns, clean-room style. It studies what the app does and how people move through it, then writes everything fresh. It never copies the target's source code, proprietary assets, logos, trademarks, copy or private APIs.

It only reads what you are allowed to read. Public pages and your own account. It never scrapes behind a login or against a site's terms, never logs into anyone else's account, and never gets past a paywall. If your account's terms forbid using it to build a competitor, it says so and sticks to public sources.

**It alwa

// HOW IT'S BUILT

// FILES

3 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • replica-architect/SKILL.md4.5 KB7d96f586d8d2upstream ↗
    ---
    name: replica-architect
    description: >-
      Plans the stack, database schema and API for an app clone, from the recon
      map replica-recon wrote. Picks boring, managed tech, turns the inferred data
      model into real SQL with indexes and access rules, lists every route by
      flow, and orders the build as a thin vertical slice first. Use when the user
      says "plan the clone", "what stack should I use", "design the database",
      "write the schema", "plan the API", "architecture for my version of X", or
      after /replica-recon finishes.
    ---
    
    # replica-architect
    
    Reads `replica/recon.md` and `replica/features.csv`. Writes
    `replica/architecture.md` (template: architecture.md in this folder).
    
    If there is no recon map, stop and run `/replica-recon` first. Planning a
    clone from memory of what an app does is how you miss half of it.
    
    ## Step 1: the stack
    
    Use what the user already knows if they have a stack. Otherwise the default,
    because every part is managed, documented and cheap at zero users:
    
    | layer | default | swap for |
    | --- | --- | --- |
    | web app | Next.js (App Router) + TypeScript | Remix, SvelteKit, Rails |
    | styling | Tailwind, tokens from replica-design | CSS modules |
    | mobile | Expo (React Native) | SwiftUI, Kotlin |
    | database | Postgres on Supabase or Neon | PlanetScale, SQLite (Turso) |
    | ORM | Drizzle or Prisma | raw SQL |
    | auth | Supabase Auth or Auth.js | Clerk |
    | payments | Stripe Checkout + Billing | Lemon Squeezy, Paddle |
    | email | Resend or Postmark | SES |
    | jobs | Vercel Cron, Inngest or Trigger.dev | a worker on Fly |
    | files | Supabase Storage or Cloudflare R2 | S3 |
    | hosting | Vercel | Netlify, Fly, Render |
    
    Write each choice with one line of why. One database. No microservices. The
    clone does not need the original's architecture, it needs the original's
    features.
    
    ## Step 2: the schema
    
    Turn the inferred data model into SQL. For every table:
    
    - `id uuid primary key default gen_random_uuid()`, `created_at`, `updated_at`
    - an owner column (`user_id` or `org_id`) on everything a user owns
    - foreign keys with an `on delete` rule decided, not defaulted
    - indexes on every foreign key and every column you filter or sort by
    - enums or check constraints for status fields
    - times as `timestamptz`, always, stored in UTC
    - money as integer cents plus a currency column
    - access rules: Postgres row level security on Supabase, or one
      authorisation check per query in the data layer. Write which.
    
    Example, for a booking app:
    
    ```sql
    create table bookings (
      id uuid primary key default gen_random_uuid(),
      event_type_id uuid not null references event_types(id) on delete cascade,
      host_id uuid not null references users(id) on delete cascade,
      start_at timestamptz not null,
      end_at timestamptz not null,
      guest_name text not null,
      guest_email text not null,
      guest_timezone text not null,
      status text not null default 'confirmed'
        check (status in ('confirmed','cancelled','rescheduled')),
      answers jsonb not null default '{}',
      created_at timestamptz not null default now(),
      constraint no_zero_length check (end_at > start_at)
    );
    create index on bookings (host_id, start_at);
    ```
    
    Then the hard constraints the recon found. Two guests booking the same slot
    is a database problem (an exclusion constraint or a unique index), not a UI
    problem.
    
    ## Step 3: the API
    
    One table per flow from the recon map. For every route or server action:
    
    `method path | what it does | who can call it | input | output | flow`
    
    Plus webhooks in (Stripe, calendar providers) and out, and background jobs
    (reminders, sync, cleanup) with their schedule.
    
    Only official, public APIs with the user's own keys. Never the original app's
    private endpoints, even if they are visible in a browser.
    
    ## Step 4: the parts that bite
    
    Write a line on each that applies: time zones and daylight saving, idempotency
    (webhooks arrive twice), race conditions, rate limits, file size limits,
    search, realtime, offline, email deliverability, multi-tenancy, GDPR deletion.
    
    ## Step 5: build order
    
    1. **Vertical slice.** The core loop end to end, ugly: sign up, do the one
       thing, see the result. Proves the stack.
    2. **Must-haves** from `features.csv`, by area.
    3. **Should-haves**, then could-haves.
    4. **The fixes** replica-entrepreneur finds, once it has run.
    
    Each milestone lists its screens (S-IDs), tables and routes.
    
    ## Output
    
    `replica/architecture.md`, the SQL in `replica/schema.sql` or as the first
    migration, and a summary: stack in one line, table count, route count, the
    three riskiest parts, and the next step: `/replica-design`.
    
  • replica-architect/architecture.md716 Bb686c60c7205upstream ↗
    # Architecture: {{your app}} (a rebuild of {{app}}'s core features)
    
    ## Stack
    
    | layer | choice | why |
    | --- | --- | --- |
    | web | | |
    | database | | |
    | auth | | |
    | payments | | |
    | email | | |
    | jobs | | |
    | hosting | | |
    
    ## Schema
    
    Tables: {{n}}. Access rules: {{RLS | data-layer checks}}.
    
    ```sql
    -- or see replica/schema.sql
    ```
    
    ## API
    
    | method path | does | who | input | output | flow |
    | --- | --- | --- | --- | --- | --- |
    
    Webhooks in: {{...}}  Webhooks out: {{...}}
    Jobs: {{name, schedule, what it does}}
    
    ## The parts that bite
    
    - time zones:
    - idempotency:
    - races:
    
    ## Build order
    
    1. Vertical slice: {{screens, tables, routes}}
    2. Must-haves:
    3. Should-haves:
    4. Fixes from replica-entrepreneur:
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/jakeschincariol-replica-skill-replica-architect.md

// REPO STATS

9.4k stars
23 open issues
Last commit: 1mo ago