Skip to main content
skill CX Codex

replica · adobe — Claude Code skill for design-preserving migration

The replica Claude Code skill moves a site to AEM Edge Delivery or another frontend while retaining its existing design. It runs for replatforming work where the visual appearance must stay close to the source.

Apache-2.0 297 installs ★ 335 updated 2026-11-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add adobe/skills --skill replica -a claude-code
Open on GitHub

What replica does

replica rebuilds key site pages on a new platform, retaining their content, structure, and appearance. It writes semantic HTML and CSS rather than copying the DOM, then checks the result against the live site with structural and pixel-difference comparisons at specified breakpoints. Design changes are allowed only when recorded in an inconsistency register.

The work then passes to migration, deployment, and rollout stages. This skill is not for redesigns. It requires Node 22+, Playwright with Chromium resolvable from the project, and the impeccable skill installed alongside stardust; its gate scripts also need pixelmatch, pngjs, and cheerio.

What it helps with

  • move a site to AEM Edge Delivery without changing its design
  • rebuild pages as clean HTML and CSS rather than copying the DOM
  • compare a migrated site with its source at selected breakpoints
  • record permitted design changes in an inconsistency register

Example prompts for the agent

  • Move this site to AEM Edge Delivery and retain its current design: <URL>.
  • Replatform this site without a redesign and compare it at 1440,360 breakpoints.
  • Migrate the site to a new frontend using the changes in --register <file>.

How to install replica

1Skills CLI (Vercel)

npx skills add adobe/skills --skill replica -a claude-code

2Manually: put the files in place

~/.claude/skills/replica/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/replica/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about replica

How do I install replica in Claude Code?

Run npx skills add adobe/skills --skill replica -a claude-code. The skill file is placed at ~/.claude/skills/replica/SKILL.md.

What does replica do?

It recreates key pages in HTML and CSS for a move to AEM Edge Delivery or another frontend. It measures the result against the source site and permits design changes only through an inconsistency register.

What does replica require?

It needs Node 22+, Playwright with Chromium available to the project, and the impeccable skill installed alongside stardust. The verification scripts also require pixelmatch, pngjs, and cheerio.

Source text

SKILL.md · Apache-2.0
---
name: replica
description: Same-design migration — re-platform a site to AEM Edge Delivery (or any clean front end) keeping its current design near pixel-perfect. Recreates key pages (one archetype per page type) as clean re-authored HTML/CSS (never DOM copies), verifies each against the live site with a measured source-fidelity gate (structural + visual + stitched pixel diff per breakpoint), then hands off to migrate/deploy/rollout for site-wide delivery (subsumes prepare-migration's prep cascade — never chain the two). The only permitted design changes are entries in an explicit inconsistency register. Use when the user says "migrate this site keeping its current design", "same-design migration", "pixel-perfect replatform to AEM", or "keep the design, change the platform". NOT for redesigns — those are the stardust core pipeline (direct/prototype) or uplift.
license: Apache-2.0
compatibility: Requires Node 22+, Playwright with Chromium resolvable from the project, and the impeccable skill (github.com/pbakaus/impeccable) installed alongside stardust.
---

# stardust:replica — same-design migration

Same pages, same content, same design — new platform. `replica` migrates a
site to AEM Edge Delivery (or just re-platforms its front end) keeping the
current design **near pixel-perfect**: the target spec IS the captured current
state, the only permitted deltas are the entries of an explicit
**inconsistency register**, and every archetype must pass a **measured
source-fidelity gate** against the live site before anything ships.

Two properties make this a different animal from the redesign pipeline:

1. **No creative decisions.** The direction step is mechanical promotion of
   the captured spec — the stardust `direct` skill is never invoked. Every judgment
   call in a replica run is a *measurement-policy* call, not a taste call.
2. **Recreation, not copying.** Archetypes are authored as clean semantic
   HTML/CSS from captured content + values lifted from the source site's own
   CSS — never DOM copies, never ported page-level stylesheets. Fidelity is
   proven by instruments, not asserted by construction.

Validated end-to-end (a typographic retail home page, 2026-07-03): 8.31% → 2.93% → **1.31%**
pixel diff in 3 measured iterations, height Δ 0, content-diff "findings:
none" (198/198 nodes). Every fix came off the instruments, never off
eyeballing.

## Inputs

- `<URL>` — required. The site to migrate.
- `--breakpoints <list>` — optional. Gate widths, default `1440,360`; each
  gets its own gate pass (mobile is not free — gate doc § Per-breakpoint).
- `--target-breakpoints <list>` — optional. Mobile-first `min-width` steps
  (e.g. `600,900,1200`) the delivered site switches layout at instead of the
  source's. Absent = source breakpoints kept, every target step below
  skipped. Persisted in `DESIGN.json` `extensions.breakpoints.target`.
- `--register <file>` — optional. User-supplied inconsistency items to seed
  the register (see Phase 2). Without it and without an audit, the register
  is empty — a pure replica.
- `--first-page <url|home>` — optional; hands-off `home`. The page a
  full-site run delivers first (`reference/first-page-first.md`).

## Setup

1. Run the master skill's setup (`../stardust/SKILL.md` § Setup): context
   loader, state read. **Flow guard.** If `state.json.flow` is
   `redesign`, refuse: print the never-mix line and the switch command
   (`$stardust replica --switch-flow`, which marks the redesign flow's
   prototyped and migrated pages stale — master skill § Two migration
   flows). If `flow` is absent, stamp `flow: "replica"`,
   `flowSource: "user-phrase"` (`../stardust/reference/state-machine.md`
   § Flow keys): invoking `replica` is the choice.
2. Verify Playwright is importable from the project root (extract needs it;
   so do the gate scripts).
3. Probe the gate's deps from the project root first —
   `node -e "import('pixelmatch').then(()=>process.exit(0))"` (and playwright,
   pngjs, cheerio) — and only on failure install them AS devDependencies,
   never `--no-save`: `npm i -D playwright pixelmatch pngjs cheerio
   --legacy-peer-deps` (`../extract/SKILL.md` § Setup). A harness that already
   resolves them leaves the delivered code repo untouched; the
   devDependencies otherwise land in the repo the skills push. Run every
   probe from the project root: ESM resolves `playwright` from the script's
   own location.
4. Copy scripts into the project and run them from there, not from the
   plugin: this skill's whole `scripts/` dir to
   `stardust/scripts/replica/`, the master skill's whole
   `../stardust/scripts/` dir to `stardust/scripts/stardust/`, the
   migrate skill's `../migrate/scripts/` (migrate.mjs) to
   `stardust/scripts/migrate/`, AND the whole `../diff/scripts/` dir to
   `stardust/scripts/diff/` (the gates import its diff-profiles.mjs and
   image-signature.mjs; keep the dirs siblings). Never copy into the project-root
   `scripts/` — that is the EDS boilerplate's directory (master skill
   § Artifacts, the write boundary).

**Reading and inspection discipline — the context is the budget**
(`reference/reading-discipline.md`, read it once at Setup). Every byte a
step prints is re-read on every later model call (recorded: 750k characters
of tool output in one 77-minute session). The rules in one line each:
reference docs by section (`section.mjs <doc> --list`, then one heading, one
section per call); captured CSS through `css-rules.mjs`, capture JSON through
`json-query.mjs` (values that feed a command from `--tsv`/`--path`, never the
table), captured HTML through `html-slice.mjs`; instrument output through
`run-bg.mjs wait` and `log --grep`, never `cat`; live-vs-prototype boxes
through `measure.mjs`, never an authored probe; any other script that opens
a page follows the recipe in `../stardust/SKILL.md` § Setup, step 7; images
one crop per fact,
never a stitched page or the live/build/diff triplet (the extract thumbnail,
`thumb.mjs`, is the one exception); script flags from
`../stardust/reference/scripts-index.md` first, then `--help`, never the
source. Write anything you will need again to a file under `stardust/` and
read it back by query.

## Procedure

Five phases. Phases 1 and 5 delegate to existing skills unchanged; phases
2–4 are owned by `replica`. A full-site run opens **first page first**:
`reference/first-page-first.md`.

### Phase 1 — EXTRACT (delegate to `$stardust extract --prep --dynamics`)

Invoke `$stardust extract <URL> --prep`, unchanged. Prep mode is required —
replica consumes the full migration inventory, not the discovery cap:

- `stardust/current/pages/<slug>.json` — per-page structure + content
  (verbatim source of every string the prototypes will carry).
- `stardust/current/assets/screenshots/` — per-page captures (ground truth
  for recreation, alongside the gate's own stitched shots).
- `stardust/current/assets/` — fonts (network-intercepted woff2), logo, media.
- `stardust/current/PRODUCT.md`, `DESIGN.md`, `DESIGN.json` — the descriptive
  current state (Phase 2 promotes these verbatim).
- `state.json.pages[].type` — page types (each becomes one archetype).
- `DESIGN.json.extensions.modules[]` — module candidates (become blocks).

When extract's summary comes back, surface it with the flow line first —
"Flow: replica — the design is kept. Say `switch to redesign` now if it is
to change." — so the first thing the user sees in this flow is the choice
it rests on. `switch to redesign` runs `$stardust prepare-migration
--switch-flow`; the extract is reused, nothing else is.

**Bounded/single-page entry (one-page or pilot runs).** `--prep` is the
site-wide contract; it is NOT the only way in. When the ask is "replicate
just this page" — or the user wants to pilot one archetype before committing
to a full migration — invoke `$stardust extract <URL> --single --dynamics`
(or `--pages <slug,...> --dynamics` for a short list) instead. This is a first-class entry,
not an improvisation: the recreation phase needs, per page, the captured
page JSON (verbatim content), the per-page screenshot (ground truth), and
the captured fonts — all of which a bounded extract provides; the source-CSS
harvest and per-breakpoint computed styles come from Phase 3's CSS lifting
either way. What a bounded run skips is the prep-only inventory (page
typing, module detection), which is only needed when Phase 5 fans out to
siblings, and the descriptive synthesis (Phase 2 takes the bounded
promotion branch, `reference/preserve-direction.md` § 1a).

Extract's failure modes apply as-is (bot-management headed fallback, consent
handling, no-synthesis rule). If extract had to fall back to headed Chrome,
expect the gate captures to need the same treatment.

### Phase 2 — PRESERVE DIRECTION (mechanical — never invoke the stardust `direct` skill)

Full contract: `reference/preserve-direction.md`. Summary:

1. **Promote** `stardust/current/PRODUCT.md`, `DESIGN.md`, `DESIGN.json`
   verbatim to the project root as the target spec. No divergence roll, no
   re-direction, no Mode A/B — the current state IS the target. **Bounded
   entry (`--single`/`--pages`): those files don't exist** — take the
   bounded promotion branch instead (`reference/preserve-direction.md`
   § 1a): synthesize a minimal descriptive spec from the captured page JSON
   + the Phase-3 CSS lift (palette, type ramp, container, buttons — exactly
   the values the lift produces anyway), provenance `bounded-single`. Never
   mix the branches: if `current/PRODUCT.md` exists, promotion is verbatim
   (first page first's Track A excepted).
2. **Write `stardust/direction.md`** recording preserve mode: what was
   promoted, from where, provenance (verbatim `--prep` promotion vs
   `bounded-single` synthesis), and the register pointer. This is what
   tells downstream skills "the direction step happened".
3. **Build the inconsistency register** at
   `stardust/replica/inconsistency-register.md` — the ONLY permitted design
   deltas, the "almost" in almost-pixel-perfect. Sources: the stardust `audit` skill
   design findings (run audit only if the user wants improvement candidates)
   and/or user-supplied items (`--register`). Every entry needs captured
   evidence + the minimal change + a status. **Empty register = pure
   replica** — that is a valid and common outcome, not a failure.
4. **Target breakpoints (only with `--target-breakpoints`)**, before any
   CSS exists (`reference/preserve-direction.md` § 4): persist the list, map
   each source breakpoint to a step by intent in
   `stardust/replica/breakpoint-map.md`, seed the ONE register entry. Phase 3
   and C0 apply the map; they never decide it.

5. **Dynamic surface (migration gate — the stardust `dynamics` skill Phases 1–3).**
   Phase 1 must have run `extract --dynamics`. Run the detector on the
   archetypes, draft the triage (`--target-origin` when the EDS host is
   known), curate `stardust/dynamic-features.md` + `-plan.md`. Every row
   gets a disposition; the static recreation continues regardless. This is
   what surfaces modals, players, forms, search, tags and host-bound APIs
   that pixel gates certify as correct. Contract:
   `skills/dynamics/reference/triage.md`.

Anything not in the register is out of scope for change. When a recreation
choice would "improve" something not registered, it is a fidelity bug.

### Phase 3 — RECREATE (one archetype per page type)

Full method: `reference/recreation-procedure.md`. For each page type in the
inventory (archetype: the type's `rep_url` in a spec's `archetypes.json`), author `stardust/prototypes/<slug>-proposed.html` (+ per-page CSS)
as **clean semantic HTML/CSS** from three sources, in this order:

(a) **Captured page JSON content — verbatim.** Headings, body, CTAs+hrefs,
    alt text, metadata from `current/pages/<slug>.json`. The migrate
    content-preservation rules (`../migrate/reference/content-preservation.md`)
    apply from the first line: no rewording, no fabrication.
(b) **Exact values lifted from the source site's own CSS.** Fetch the live
    stylesheets; lift the type ramp, button specs, section paddings, radii,
    shadows, hero heights. The container model is measured, not lifted —
    DESIGN.json `extensions.breakpoints` (extract's `cap-probe.mjs` run; a bounded
    entry runs `cap-probe.mjs <live-url> --write-design stardust/current/DESIGN.json` first).
    **Fidelity values come from the original site's CSS, not the eye** — this
    converts 3–4 guess-and-screenshot loops into one. Box-by-box comparison of
    the live page against the served prototype goes through the shipped
    `measure.mjs` (`node stardust/scripts/replica/measure.mjs <live-url>
    --against <prototype-url> --selectors "<css>,…"` — rect + computed values
    per selector per width, one delta line each), never through an authored
    probe.
(c) **The captured screenshot as ground truth** for everything CSS doesn't
    name (composition, image crops, paint effects).

**With a target set, every `@media` rule and JS width threshold
(`matchMedia`, `innerWidth`) is authored on the target steps from the first
line** per `breakpoint-map.md`, never fixed later (a retrofit costs a full
re-gate); `breakpoint-lint.mjs` exits 0 on a prototype before its gate.

**Every archetype gets its own standalone prototype — cumulative, never
skipped.** Never skip to direct platform authoring for a new archetype:
prototyped archetypes stayed the quality ceiling in the field (3.5%/5.6%)
while direct-authored pages plateaued at 8–16%. Each new prototype imports
the shared layers earlier ones already gated (shared canon CSS + a
per-archetype file) and iterates only on its NEW modules — full contract:
`reference/recreation-procedure.md` § Cumulative archetype prototypes.

**This is recreation, not redesign — do NOT delegate to impeccable craft.**
Impeccable's redesign gates (critique, anti-template, divergence) do not
apply; the source-fidelity gate (Phase 4) replaces them entirely. A
"tastefully improved" section is a failing section.

**Fonts:** use the same public source when available (extract's intercepted
woff2 for open/self-hostable faces). For licensed commercial kits: never
rehost on the new domain — pick a metric-matched substitute, keep the brand
family name first in the font stack so a licensed drop-in later wins, and
surface the substitution to the user. (Prior art: an earlier airport-site migration's improvement notes, §3.7.)

**CSS-portation is the per-section fallback only** — paint-level effects not
recoverable from computed styles, JS-hydrated commerce widgets, video or
animated heroes. Port the minimal source rules for that section, scoped;
never page-level. Criteria in `reference/recreation-procedure.md` § Fallback.

### Phase 4 — SOURCE-FIDELITY GATE (the heart — measured, per breakpoint)

Full contract: `reference/source-fidelity-gate.md`. Run per archetype, per
breakpoint (default 1440 AND 360), live URL as source vs served prototype:

```bash
PROTO="http://localhost:8791/<slug>-proposed.html"   # python3 -m http.server from the prototypes dir
# ONE server, ONE port — probe with curl first (gate doc § Per-breakpoint procedure): no answer →
# start yours; answers but not your file → foreign server, never kill it, take a per-project port
curl -sI localhost:8791/<slug>-proposed.html | head -1   # 200 = it serves YOUR dir: reuse it
LIVE="https://<site>/<path>"

# One command per round — gate.sh, through run-bg. The FIRST round of a breakpoint and the
# CONFIRMATION round after the last fix run `--full` (pixel probe — stitched captures, NEVER
# fullPage:true — plus content-diff, visual-diff and chrome-parity under deadlines, one verdict
# line each, reports in the gate dir); rounds in between are pixel rounds. Never hand-write a
# wrapper around the instruments (a recorded one lost the deadlines; a round took 15 minutes).
# content-diff inside --full compares --main AND the header/footer roots by default — no chrome flag.
node stardust/scripts/replica/run-bg.mjs start --name <slug>-1440-iter1 -- \
  stardust/scripts/replica/gate.sh <slug> "$LIVE" "$PROTO" 1440 iter1 --full --main "<content-root>"
node stardust/scripts/replica/run-bg.mjs start --name <slug>-360-iter1 -- \
  stardust/scripts/replica/gate.sh <slug> "$LIVE" "$PROTO" 360 iter1 --full --main "<content-root>"
# A consent manager the built-in candidates miss: add --consent "<accept selector>" to every gate.sh
# round — it reaches both stitched captures and the probes alike (gate doc § Hardening rule 6).
node stardust/scripts/replica/run-bg.mjs wait      # verdict lines: pixel %, height delta, hot bands, structural 🔴, flags, chrome deltas

# Iteration inner loop (gate doc § Band breakdown): anchor probe + pixel round
G=stardust/replica/gates/<slug>-1440
node stardust/scripts/replica/anchor.mjs "$LIVE"  --width 1440 --cache $G/anchor-live.json   # live side: probed once, reused
node stardust/scripts/replica/anchor.mjs "$PROTO" --width 1440   # build-side runs are free
# Chrome: computed-style parity BEFORE any pixel round on header/footer/strips
node stardust/scripts/replica/chrome-parity.mjs "$LIVE" "$PROTO" --width 1440 --live-cache $G/chrome-live.json   # exit 0 = quiet, then crop-compare
# Every instrument runs real Chrome headless with its real user agent and client hints (#151); existing automation-signal handling stays on unless STARDUST_STEALTH=0; STARDUST_HEADED_WINDOW=1 opens the --headed window (#125).
# gate.sh: live.png cached, every step under a deadline (exit 124 = re-run, not FAIL). Rounds run in
# the BACKGROUND: start every round at once (the slots pace the Chromiums — no `sleep N;` staggering),
# then `wait` prints verdict lines only; exit 75 = still going → `wait` again as your NEXT step, never
# in a shell loop, never after a `sleep` (gate doc § Iteration discipline). A propagation wait is a
# bounded inline poll (`curl -sf` ≤ 5 s apart, capped), never a fixed sleep.
node stardust/scripts/replica/run-bg.mjs start --name <slug>-1440-iter2 -- stardust/scripts/replica/gate.sh <slug> "$LIVE" "$PROTO" 1440 iter2
node stardust/scripts/replica/run-bg.mjs start --name <slug>-360-iter2  -- stardust/scripts/replica/gate.sh <slug> "$LIVE" "$PROTO" 360  iter2
node stardust/scripts/replica/run-bg.mjs wait      # returns within 100 s; full output: run-bg.mjs log <job> --grep <re>
# Content-cap row — once per archetype after the 1440 pass, at DESIGN.json's derived probeWidth (never a pinned 1920)
node stardust/scripts/replica/cap-probe.mjs "$LIVE" --against "$PROTO" --design DESIGN.json --slug <slug> --main "<content-root>"
```

`gate.sh --help` lists the flags and exit codes (124 = deadline, re-run, not
a verdict; 0 only when all four ran and passed).

**Pass bar (all four per breakpoint, plus the content-cap row):**
- content-diff: **0 🔴 and 0 nothing-lost 🟡** on the main and chrome roots (gate doc § Pass bar item 1);
- visual-diff: flags none or justified;
- pixel diff: **≤ 10%** full-page, with no per-500px band left unexplained
  (the band breakdown is the navigation instrument — fix the first hot band,
  top-down; everything below it is offset-contaminated);
- height delta **|Δ| ≤ 8px** (pixel-compare's own warning bar);
- **content-cap row: `cap-probe.mjs … --against` prints `cap-probe: PASS`**
  (gate doc § Pass bar item 6 — every live cap held within ±20 px by kind,
  nothing capped only on the prototype; a ✗ names the sizing rule, no pixel iteration);
- **clip-probe: `Clipped: 0`** on the build side (a `--full` round runs it; cut or hidden
  text / controls fail the round like an over-threshold pixel diff — #125); a
  declared repeated-unit family (`stardust/replica/units.json`, gate doc item 7)
  within 4 px;
- and, outside the bar and outside the cap, the horizontal-overflow assert:
  `document.documentElement.scrollWidth` within 4 px of the viewport
  (integer rounding; `GATE_OVERFLOW_TOLERANCE`) at every breakpoint on the
  build side — gate.sh fails the round on more whatever the pixel number
  says; a `capture failed (exit 1)` round (after gate.sh's one
  retry) is re-queued, never counted.

**With a target set (#131):** gate widths add each target step; inside a
shifted band a pixel failure is **tier-shift** (logged against the register
entry, never iterated) or a **defect** (still fails) — gate doc § Target
breakpoints.

**Every prototype is a row (#125).** When the archetypes pass, one run per width
writes the prototype table — `node stardust/scripts/replica/gate-all.mjs --stage
prototype --proto-base "$PROTO_BASE" --width 1440` (then 360) through `run-bg.mjs`;
it reuses each archetype's cached `live.png`. `gate-evidence.mjs` reads it as the
source of record: a prototype without a row is ungated.

**Iteration discipline: hard cap 3 iterations per breakpoint.** Each
iteration's fixes come off the instruments, never off eyeballing. After 3,
log the residuals in the ledger and move on — a documented 2% residual beats
an undocumented fourth loop. **No single step waits longer than the context
cache lives:** long instruments go through `run-bg.mjs` (`start`, then `wait`
in ≤ 100-second slices), main agent and subagents alike — a long instrument
in the foreground, or two as parallel tool calls in one turn, is the same
blocked step (reference doc § Iteration discipline).

**Hardening (each is a recorded false-measurement trap — see the reference
doc for the full list):** real Chrome headless with **its own identity plus
the standard request headers** on every capture, live navigations paced per
host (built into the shared `skills/stardust/scripts/live-session.mjs`); a
challenge/blocked interstitial or a
2xx denial page **fails loud (exit 3)**, never measured — escalate with
`--headed`, and a site that still blocks needs crawl.mjs-class capture;
`domcontentloaded` on live targets, never `networkidle`;
symmetric `--main` scoping on both sides (`--main body` is never valid);
both overlay classes dismissed via `--dismiss` (consent AND timed marketing
modals); animations frozen for capture; the pointer parked after any
dismissal click; fixed/sticky chrome replicated fixed, with its
scroll-state morph (`reference/recreation-procedure.md` § Fixed and sticky
chrome);
granularity-parity policy for JOIN/SPLIT false-reds (#87); capture-state
policy for CDN-403 images and hydration placeholders (replicate as captured
+ log). Two defect classes only the gate catches — DOM/style capture misses
them: rendered-face font forks on inner spans (width probe) and overlay
scrims invisible to computed styles (recover by per-row luminance fitting).

The live-target hardening ships as flags on the diff scripts (`--ua`,
`--wait-until`, `--dismiss`, `--headed`, `--locale`, visual-diff `--main`)
backed by the shared `skills/stardust/scripts/live-session.mjs` — pass flags; a project
copy carrying hand-edits is a defect
(`reference/source-fidelity-gate.md` § Script adaptations).

**After the static gate passes, interaction parity is a REQUIRED gate
output per archetype — not a post-pass**
(`reference/recreation-procedure.md` § Interaction parity). Motion is OBSERVED,
never inferred from static classes or CSS: run
`stardust/scripts/replica/motion-observe.mjs` per archetype live URL →
`stardust/replica/motion/<slug>.json`, implement ONLY behaviors that
fired (dead classes = NOT implemented), then observe the served prototype
with the same `--click`/`--hover` pokes in the same order (→
`stardust/replica/motion/<slug>-build.json`) and compare the two files with
`stardust/scripts/replica/motion-compare.mjs`, a reporter, not a gate (the
header's behaviour is the header contract's): a MISSING or EXTRA line is
confirmed on the class lines (the sampler misses class-toggled and
pseudo-element mechanics) and resolved in the prototype or recorded as dead.
Record
`motion: {observed, implemented, dead[]}` in `progress.json`, and re-run
pixel-compare — the number must return to the gated value.
Widgets are implemented, not justified away — on EDS as `widgets/<path>/<name>`
when the component carries no authored content, never a block with empty rows.
Timer-driven media counts as fired (`autoplay`/`loop` video, auto-advancing
slides — the observe JSON's `media` block): the capture freeze is logged as
`captureState[].restoreAtDelivery` and delivered, never shipped as the spec.
Fan-out briefs carry the
evidence rule + instrument invocation verbatim.

When all breakpoints pass, present the archetype + its gate metrics for
approval per the standard prototype approval flow (hands-off mode records
`approvedBy: "hands-off"` per `../stardust/reference/state-machine.md`).
Bookkeeping is one command each, never a hand-built JSON line or an inline
`node -e` edit of state.json: `node stardust/scripts/stardust/state.mjs advance <slug> --to
approved --by hands-off --prototype stardust/prototypes/<slug>-proposed.html`
and `node stardust/scripts/stardust/ledger.mjs replica source-fidelity-gate
end --detail "<per-breakpoint numbers>"`. Resuming a run starts with
`ledger.mjs tail` and `state.mjs summary --slugs`, not `cat`.
Every phase of this skill — extract and preserve-direction included — opens
with `node stardust/scripts/stardust/ledger.mjs replica <phase> start` as its
FIRST command, before any script of the phase runs (a recorded hands-off run
wrote a phase's `start` beside its `end` after 109 minutes of work and read
as idle to its supervisor; `ledger.mjs` refuses an `end` without an open
`start` under `--strict`), and closes with the `end` line plus a section in
`stardust/journal.md` headed `## <Phase name> — <what happened> (<date>)` —
the section is part of the phase `end`, and `ledger.mjs … end` warns when it
is missing (a recorded run's journal began at its second session; another's
had one section for the whole run).

### Phase 5 — HANDOFF (delegate — migrate → deploy → rollout, unchanged)

- **Read the contract card first: `reference/handoff-contract.md`** — the
  distilled migrate/deploy/rollout rules this phase needs, the exact rollout
  ledger phase strings (`A-inventory` … `I-dashboard`), one usage line per
  deploy and rollout script, and the bookkeeping commands. Never read the
  sibling SKILL.md files whole (one recorded session read 260k characters
  of them, then re-read the overflow, before its first Phase 5 output);
  fetch a cited section with `section.mjs` only when a step needs depth.
- **Pages beyond the archetypes** go through the stardust `migrate` skill at
  **sibling tier** (`../migrate/reference/fidelity-tiers.md`) — and only
  AFTER their archetype is live and gated at the published origin (contract
  § 3 row C, unit `C-archetype`; #126): structural clone as the encoder's
  input + content-fidelity + delivery-lint + media-reconcile; the sibling's
  only counting number is its gate row after PUT + preview (no local pixel
  bar). Siblings inherit the archetype's proven encoder — never re-author one. **Template constancy is measured, not
  assumed**: before cloning, run `stardust/scripts/replica/sibling-variance.mjs
  <archetype> <siblings…> --probe <block>=<sel> …` once per template and
  budget every delta as a block VARIANT class on the sibling's content (same
  file, § Sibling variance probe). Content-fidelity is
  **measured per page at import time** (same file, § Content-count
  acceptance) so importer bugs surface while cheap to fix.
- **Delivery** via the stardust `deploy` skill per page. Bias the decode tier toward
  **template-slotted** for fixed-composition sections (deploy #95): replica
  sections are fixed compositions matched to a live original.
  Repeat groups (cards, listings) stay reconstructive. **Blocks
  obey the Experience Workspace editability contract (deploy § 8, EW1–EW10:
  node-slotting, never value-slotting) and pass `block-roundtrip --ew`.**
- **Site-wide rollout** via the stardust `rollout` skill, unchanged — its block dedup
  is what implements "same blocks across the whole site".
- **Target breakpoints:** C0 authors the foundation and reused blocks on
  the target steps and wires `breakpoint-lint.mjs` into `npm run lint`
  (`reference/handoff-contract.md`), so every deploy and rollout lint pass
  enforces it.
- **C-deliver runs in units** (`reference/handoff-contract.md` § 3, row C +
  Fan-out discipline): C0 — ONE foundation subagent authors AND deploys the
  foundation; the main agent gates the shell on the published origin, the
  header contract included (`chrome-compare` exit 0, `../diff/SKILL.md`
  § The header contract), then `foundation-freeze.mjs freeze` + commit; C-archetype — per template, the
  gated archetype is deployed and passes its full gate row on the preview URL
  (cap 3 fix rounds, then the re-prototype decision) BEFORE its siblings
  render; C1…Cn — one subagent per template
  cluster runs the whole chain, PUT → preview → published-origin gates
  included, with its own batch ledger (`deploy-batch.mjs --ledger …`,
  lock-safe) and reports one verdict line; the main agent only coordinates
  and records; C-final — `check`, the queued `foundation-requests.md` lines
  applied once, `C-deliver end`. Each unit is recorded in
  `stardust/rollout/progress.json` and committed — a safe resume point,
  never by itself a reason to end the session; no frozen file is edited
  mid-wave.
- **The final gate runs against the PUBLISHED origin — not the harness**
  (`reference/source-fidelity-gate.md` § The published-origin gate): deploy
  first (`PUT → preview`), then `gate.sh <slug> "$LIVE" "<preview-url>"
  <width> pub1 --full --marker "<brand or domain string>"` through
  `run-bg.mjs`, in the ordinary `gates/<slug>-<width>/` dir under the `pub<N>`
  label (a new dir would force a fresh live capture). Nothing pixel-shaped
  runs on the local harness — it feeds `qa-gate`/`block-roundtrip` only.
- **The delivery gate is the ALL-PAGES run, four criteria — not the pixel
  number alone** (`reference/source-fidelity-gate.md` § The all-pages
  published-origin...

© adobe · Apache-2.0 · adobe/skills

Similar skills

All skills for Frontend and UI →

replica by other authors comes first.

replica albertirgi The replica Claude Code skill rebuilds a page or component from a URL, file, screenshot, or screen recording. It compares the result with the reference and repeats fixes until the numeric score passes. CX Codex +1 ★ 128repo stars replica-deploy Jakeschincariol replica-deploy prepares an app clone for release on your own domain with preflight checks, production setup and DNS guidance. Use it before going live. CX Codex +1 1,600installs simota-agent-skills podo simota-agent-skills — a collection of design skills for interface direction, Figma context, mockup-based HTML/CSS, and UX copy. Call a focused skill or let Vision coordinate design work. CX Codex +1 199installs replica-design Jakeschincariol replica-design is a Claude Code skill that rebuilds an app clone’s design system from screenshots as tokens, styles, and component specs. It supports screenshot-based interface reconstruction. CX Codex +1 1,600installs image-to-ui UIZZE image-to-ui is a Claude Code skill that turns screenshots, mockups, and sketches into interface code, then renders and compares it with the original to fix mismatches. CX Codex +1 138,900installs guizang-social-card-skill op7418 guizang-social-card-skill builds carousel images and covers for Xiaohongshu, WeChat, and articles from text, screenshots, or video using Swiss design and magazine layouts. CX Codex +1 5,600installs remake Ruben Hassid from the newsletter How to AI The remake Claude Code plugin recreates websites pixel for pixel. It then sends a private copy to GitHub and Vercel. ★ 386repo stars

From the same set108

The whole set →
adobe-edit-quick-cut adobe-edit-quick-cut turns a video into one highlight cut by selecting relevant moments. Use it for a teaser, sizzle reel, or visual summary. CX Codex +1 308installs cwv-optimizer cwv-optimizer diagnoses Core Web Vitals bottlenecks on AEM Edge Delivery Services sites and offers targeted fixes with score projections. CX Codex +1 306installs adobe-resize-photos-and-videos adobe-resize-photos-and-videos scales photos and videos to explicit pixel sizes or aspect ratios via Adobe tools. Useful when prepping files for web display, print, or video channels. CX Codex +1 303installs audit Audits a website for design, SEO, technical health and AI-search visibility, then turns the findings into a scored report. CX Codex +1 301installs reskin reskin rebuilds your site's pages in the design of another site or a set of HTML prototypes, keeping the content and SEO metadata intact. Fits a rebrand with the same content. CX Codex +1 293installs cdp-connect The cdp-connect skill describes attaching to an existing Chrome session over CDP. It is superseded by the web CLI, which handles browser commands and screenshots. CX Codex +1 292installs page-tree page-tree extracts rendered webpage layout into a spatial tree with element bounds, CSS grids, and selectors using Playwright. CX Codex +1 285installs page-collect page-collect pulls icons, metadata, text, forms, videos and social links from a page via the web CLI. Use it when migrating to Edge Delivery Services or auditing a site. CX Codex +1 283installs

Project sponsors

Companies that keep this analytics open