Our sandbox passed all 57 tests for replica-skill at commit 77c9436. For developers considering a supervised app rebuild, that is a useful starting point for inspecting the pack. Its shared reconnaissance files and feature matrix give you something concrete to review before implementation. Avoid it if you expect installation to deliver an autonomous, complete application or a ready-made deployable service.
Replica-skill is Jake Schincariol's MIT-licensed collection of eleven Claude skills for studying, rebuilding, testing, rebranding, and launching apps. Its organizing idea is the handoff: reconnaissance produces files that later stages read, so assumptions have a place to be reviewed and corrected. The upstream replica-skill README describes the sequence, installation routes, and six accompanying Python helpers. Start by reading those artifacts as proposed requirements for the application you intend to build.
What you can do with replica-skill
Replica-skill organizes an app rebuild around shared files in a project's replica/ directory. Reconnaissance maps screens, flows, components, and an inferred data model. Architecture and design turn those observations into implementation choices and design tokens. Build and backend instructions then use that material. Before implementation begins, a developer can review the behaviors the agent believes the application needs and correct the written assumptions.
The eleven stages cover recon, architecture, design, build, backend, test, diff, entrepreneur, brand, launch, and deploy. The README also permits running an individual skill. Reconnaissance is a practical starting point when you already understand a reference application's flow; complaint analysis suits an earlier product decision, when you are still deciding which behavior to rebuild and what your version should change. Choose the stage according to the decision you need to make.
| Helper | Documented job | Useful next action |
|---|---|---|
imgdiff.py |
Compare PNG edge maps while ignoring color | Inspect layout regions that differ after rebranding |
parity.py |
Weight required and optional features | Review missing required behaviors |
contrast.py |
Check token contrast | Inspect unreadable color combinations |
reviews.py |
Group supplied reviews while retaining linked quotes | Read the input rows behind a complaint theme |
sweep.py |
Find the original brand's remnants in code | Inspect matching names, domains, and colors |
listing.py |
Check store-listing limits and copycat wording | Revise flagged submission copy |
The two comparison helpers answer different questions. According to the README, imgdiff.py compares edge maps so a palette change does not count against layout similarity. parity.py works from the feature matrix and marks missing must-haves as unshippable. A developer can therefore review layout differences separately from required functionality, then use the relevant output to decide what to inspect or implement next.
What people use replica-skill for
Argusic's reported use covers installation, unit tests, and all six Python helpers at commit 77c9436. The supplied synthesis attributes that account to argusiccom on X and names imgdiff, parity, contrast, reviews, listing, and sweep. This is a report about exercising the repository's tools. The README supplies a different kind of example: a scheduling application used to explain how the eleven stages exchange files and decisions.
The README's scheduling-app example starts with a screen map and feature matrix, then orders the booking flow first. Backend work adds Calendar integration, payments, and reminder email. The example carries the same project through tests, feature comparison, complaint analysis, branding, and launch preparation. Its practical value is showing which artifact feeds the next decision, particularly when a developer needs to trace an implementation choice back to an observed behavior.
For an initial evaluation, choose a booking or account flow you already know well and inspect the reconnaissance output. Check whether the recorded states and transitions match that flow before asking an agent to implement them. This uses the pack's shared-file structure directly: correcting a rule in the recon map gives the later architecture and backend stages a clearer starting point. Keep the feature matrix beside that map as you review scope.
What happened when we ran it
Our sandbox installed replica-skill in 7 seconds, built it in 1 second, and passed all 57 pytest tests in 3 seconds. The run used commit 77c9436 on November 13, 2026, with 3 CPUs and 8 GB of RAM. We measured 35 dependencies and 38 MB on disk. The recorded install, build, and test steps all succeeded under the supplied harness configuration.
| Sandbox check | Recorded result |
|---|---|
| Install | Succeeded in 7 seconds |
| Dependencies and installed footprint | 35 dependencies recorded, 38 MB on disk |
| Build | Succeeded in 1 second |
| Tests | Succeeded in 3 seconds, 57 passed, 0 failed of 57 |
| Dependency audit | pip-audit reported 0 known vulnerabilities |
| Checkout | 39 files, about 2,303 source lines, 0.2 MB |
| Repository signals | Tests directory present, 0 CI workflow files, no Dockerfile |
The recorded sandbox image was ghcr.io/astral-sh/uv:python3.12-bookworm. The README describes the six helpers as standard-library Python and says there is nothing to install with pip. Our harness recorded an environment containing 35 dependencies. The 35-dependency count and 38 MB footprint describe that harness environment; the README's installation statement describes the helpers. Use the documented Python requirement when preparing to inspect the scripts.
The separate deployment runner failed its safety step because none of compose.yaml, compose.yml, docker-compose.yaml, or docker-compose.yml existed. Its rule required a Compose file and labeled the repository unsafe. That label describes the failed runner requirement. The run header, dated 2026-11-13, says deployment used the repository's own Docker Compose with every port bound to 127.0.0.1; the failed step contradicts that summary. The teardown record says teardown: ok.
Where people get stuck: malformed screenshots and command names
Issue #10 reports that imgdiff.py crashes when a PNG's IHDR chunk is truncated. The PNG failure report traces the error to read_png, where struct.unpack expects a 13-byte buffer. The reporter proposes checking the chunk length before unpacking and raising PngError through the existing error-handling path. The supplied issue record is open and presents this change as a suggested fix.
Issue #10 describes a screenshot truncated during saving or an IHDR chunk with a malformed length. Its reproduction calls for keeping only the first 20 bytes of a valid PNG or emitting an IHDR chunk declaring length 12. Preserve the failing input when investigating the report, and inspect the selected revision's handling before putting screenshot comparison into an unattended workflow. The other supplied tracker URLs are issue #28 and issue #15.
| Symptom | Evidence or explanation | Practical response |
|---|---|---|
| Raw PNG traceback | Issue #10 identifies an unchecked IHDR buffer length | Preserve the input and inspect the selected revision for the proposed length check |
| Expected slash command absent | README says plugin commands receive a namespace | Use /replica-skill:replica-recon for the plugin route |
| Chat instructions lack local helpers | README says pasting SKILL.md loses the Python tools | Choose a local environment with file and script access for helper work |
| Deployment runner refuses the repo | Our safety step required a Compose file | Use the documented skill-pack installation route |
Claude installation has two different command forms
The README documents plugin installation and folder-copy installation, with different slash-command names. The following commands are reproduced from the installation instructions: they register the repository's marketplace and install its plugin. Choose the route before following later examples, because a copied folder and an installed plugin expose reconnaissance under different command names. These are documented instructions, rather than a transcript of our sandbox's installation commands.
/plugin marketplace add Jakeschincariol/replica-skill
/plugin install replica-skill@replica-skill
The plugin exposes /replica-skill:replica-recon; copied folders expose /replica-recon. The README places global copies in ~/.claude/skills/ and project-local copies in .claude/skills/ inside the repository. A project-local copy keeps the instructions alongside the application being developed. Start reconnaissance with the reference app's URL, then read the resulting screen and flow map before proceeding to architecture. Keep the installation route in mind when reading the README's shorter command examples.
The pack's README says no signup or API key is required for the pack itself. Its scheduling example uses the builder's Google keys for Calendar integration, Stripe for paid bookings, and reminder email. Those choices belong to the resulting application's setup. Treat service selection and credentials as implementation decisions when reviewing the architecture, and account for the services you choose separately from the repository's MIT license.
Complaint analysis keeps links attached to input rows
The README says reviews.py drops reviews without links and copies each printed quote from a supplied row with that row's URL. It marks themes thin when they contain fewer than three reviews or only one source. That gives a developer a direct route back to the material behind a proposed feature change, instead of leaving a complaint summary detached from its inputs.
The practical review task is to inspect those inputs before changing positioning or implementation priorities. Keep the original CSV with the analysis, read the linked complaints, and distinguish an old-version problem from a repeated complaint about the flow you are rebuilding. The script's grouping rules provide an accounting structure; the developer chooses the dataset and decides which complaints matter to the intended product. Review those choices alongside the resulting themes.
The feature matrix also makes scope choices visible. According to the README, parity.py weights must, should, and could features, gives partial features half credit, and excludes deliberate omissions and additions. Review those exclusions before acting on a parity score. The matrix is most useful when the developer can explain why a behavior is required, optional, deliberately omitted, or newly added, and can carry that explanation into the implementation plan.
Security boundaries depend on the host agent
Developers must review the host agent's permissions before letting the workflow operate accounts or deploy an application. The README describes all six helpers as local scripts that do not touch the network. Backend and deployment instructions address a broader job, including authentication, payments, integrations, and production setup. An agent writing application code or operating accounts has responsibilities beyond the input-and-output work of a contrast or listing helper.
The documented process calls for fresh code and assets, restricts observation to permitted sources, and requires a new brand before launch. Public pages and the builder's own account are its stated observation sources. The README also says to use public sources when account terms forbid building a competitor. These instructions give a developer specific behaviors to check while supervising reconnaissance, reviewing implementation choices, and preparing the resulting application for release.
Our dependency audit returned zero known vulnerabilities. For application work, keep account permissions and authorization rules in the release review alongside dependency checks. A useful review question is whether one user's records are protected from another user's requests. That question follows from the backend responsibilities in the workflow and gives the developer a concrete security task to carry into implementation, particularly when reviewing generated authentication and database code.
replica-skill vs Superpowers, Skills for Real Engineers, and a standalone prompt
Replica-skill centers on rebuilding a reference app; Superpowers describes a general development methodology; Skills for Real Engineers emphasizes adaptable individual skills. The Superpowers upstream README describes specification, implementation planning, and red/green TDD. The Skills for Real Engineers README says its skills are small, easy to adapt, and composable. Choose among these structures according to the process you need to review and maintain.
| Option | Documented emphasis | When to choose it |
|---|---|---|
| replica-skill | Reference-app recon followed by implementation, comparison, branding, and launch | You want shared artifacts across an app-rebuild sequence |
| A standalone reverse-engineering prompt | Explainx describes a related core approach with fewer surrounding product steps | You want a bounded investigation |
| Skills for Real Engineers | Small, adaptable, composable engineering skills | You want to fit individual practices into an existing workflow |
| obra/superpowers | Specification, planning, test-driven development, and review | You want a general engineering methodology |
The SkillsLLM comparison uses popularity signals and explicitly calls them indicators of community interest. For an adoption decision, the upstream descriptions provide a more useful distinction: choose the reference-app sequence, a general development process, or individual skills according to how you want work organized. Begin with the artifacts you want to inspect and maintain, then select the workflow that produces them.
What the other reviews get wrong
SkillsLLM says neither compared project includes a SKILL.md file, but replica-skill's upstream README lists those files throughout its skill folders. That corrects the blanket absence claim in the SkillsLLM comparison. A reader can inspect the listed locations for recon, architecture, design, build, backend, test, diff, entrepreneur, brand, launch, and deploy before choosing which instructions to install or copy into a project.
Grabthatidea's Facebook pitch for Replica Skill says it can recreate an app's design and functionality in minutes. The upstream README says a booking tool is weeks of work and gives no perfect-clone guarantee. For planning purposes, use the README's task description: reconnaissance, implementation, testing, integrations, and launch are separate stages with their own decisions and outputs. Installation time and application-development time answer different questions.
The supplied synthesis quotes Explainx's repository snapshot as dated October 12, 2026, including its one-commit description. That is a dated observation. The supplied PNG issue was opened on October 18, 2026 and adds a specific robustness report. Read the historical repository description with its date attached, and use the issue's reproduction when deciding what screenshot handling to inspect in the selected revision.
FAQ
Jakeschincariol/replica-skill is Jake Schincariol's app-rebuilding skill pack, with eleven workflows and six Python helpers. Its README documents plugin and folder-copy installation and explains how the workflows share project files. The questions below cover the pack's contents, repository identity, creator, and Claude command forms. Use the owner and repository name to distinguish it from similarly named projects before following installation instructions.
What are replica-skills, and what does the pack include?
Replica-skill includes eleven workflows and six Python helpers, according to its README. The workflows cover recon, architecture, design, build, backend, test, diff, entrepreneur, brand, launch, and deploy. They use shared project files to carry observations and decisions between stages. Individual skills can also be used separately, including complaint analysis before committing to a rebuild and reconnaissance before choosing an implementation plan.
Where is the GitHub repository for replica-skill?
The repository is Jakeschincariol/replica-skill, whose README credits Jake Schincariol. Use that owner and repository name when locating the app-rebuilding pack. Replicate's similarly named offering has a different purpose: its agent-skills documentation describes finding, comparing, running, and prompting AI models. The repository identity distinguishes the rebuild workflow reviewed here from those model-development instructions.
How do I install and use replica-skill with Claude?
The README documents a Claude Code plugin and copies of the skill folders in Claude's skills directories. Plugin commands include the namespace, such as /replica-skill:replica-recon; copied folders use /replica-recon. Choose global or project-local scope, start with the reference app's URL, and inspect the reconnaissance output before proceeding. The installation section above reproduces the documented plugin commands and explains the two command forms.
Who is Jake Schincariol, and is he the creator of replica-skill?
Jake Schincariol is the creator credited in the replica-skill README under the GitHub owner Jakeschincariol. The repository's credit and MIT license identify the author and reuse terms for this pack. The README separately instructs builders to write fresh code, use their own assets, and rebrand the resulting application. Those instructions distinguish reuse of the skill pack from copying a reference product's code or proprietary materials.
What we have not tested yet
The supplied records contain no completed application built through all eleven stages or successfully deployed resulting product. The scheduling walkthrough is explicitly an example, and the synthesis describes Argusic's account as exercising the helpers. The separate Compose attempt stopped at its safety step despite its deployment header. There are no screenshot records or known-answer application questions in this pack. We have not tested the proposed malformed-PNG fix or reproduced issue #10 locally.
The sandbox image label records configuration rather than the actual interpreter or operating-system version. Raw toolchain logs would be needed for those versions, and the supplied record does not identify the package-by-package dependency footprint. Cross-host listings supply no execution results for each advertised assistant. Browser execution, Playwright integration, manual handoffs, and assistant activation through the documented installation routes remain outside our measured work. The installation commands above were copied from the README, not executed for this correction.
The review helper preserves supplied quotes and URLs; independent review-authenticity checks are not demonstrated here. Production security, throughput, model spending, support responsiveness, rendered page layout, resolved links, recommendation modules, and template behavior also lack measured results. All four numerical ratings remain unassessed because the evidence does not support a fair five-point judgment of assistant activation, documentation success across the workflow, community support, or application-building maturity.


