Przejdź do treści
Biblioteka skilli
Projektowanie i UX · Analiza

pixel-clone

/pixel-clone

Analizuje stronę internetową i przygotowuje specyfikację do odbudowy od zera: trasy, treści, układy, tokeny designu i przepływy.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
16
Skrypty
6
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 6 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: assets/dither-canvas.tsx, assets/dither-kit.mjs, assets/recon-workflow.template.ts, assets/skeleton.py, assets/split_landing.py, assets/stitch-pngs.mjs

Co robi i kiedy

Analizuje stronę internetową i przygotowuje specyfikację do odbudowy od zera: trasy, treści, układy, tokeny designu i przepływy.

Wyzwalacze z opisu

rebuild specanalyze this sitecopy X
Oryginalny opis (EN)

Reverse-engineer a website into a from-scratch rebuild specification — public-site recon (routes, verbatim copy, layout blueprints, design tokens, legal outlines) plus an optional logged-in app walkthrough (shell, chat/dashboard, settings, billing, quota flows, mobile pass) and a working 1:1 clone. Use whenever the user asks to analyze, clone, copy, or recreate a site's design, reverse-engineer a competitor, extract a design system, produce a "rebuild spec", or make a pixel-perfect replica — even if they just say "analyze this site" or "copy X's design". Produces fact-checked markdown delivera

Jak działa

  1. Phase split — decide before starting
  2. Explain before code (hard gate)
  3. Operating lessons (learned the hard way — do not re-learn them)
  4. Deliverable contract
  5. Execution order
Sekcje z nagłówków SKILL.md, w oryginale · 210 linii, 2 041 słów
Podgląd SKILL.md
---
name: pixel-clone
description: >
  Reverse-engineer a website into a from-scratch rebuild specification — public-site recon
  (routes, verbatim copy, layout blueprints, design tokens, legal outlines) plus an optional
  logged-in app walkthrough (shell, chat/dashboard, settings, billing, quota flows, mobile
  pass) and a working 1:1 clone. Use whenever the user asks to analyze, clone, copy, or
  recreate a site's design, reverse-engineer a competitor, extract a design system, produce
  a "rebuild spec", or make a pixel-perfect replica — even if they just say "analyze this
  site" or "copy X's design". Produces fact-checked markdown deliverables with per-claim
  evidence and reuse-vs-replace rules.
license: MIT
metadata:
  author: MD Ibrahim Arman
  version: "1.4.0"
---

# PixelClone — site rebuild & 1:1 replica specs

Produce the two markdown deliverables a developer needs to rebuild a target site from
scratch under **original branding**: a **public-site rebuild spec** and (when the site has a
logged-in product) a **companion app spec**. Everything is evidence-first: every claim carries
its source (URL, fetched HTML/CSS/JS chunk, screenshot, or DOM snapshot), and anything not
captured is listed under "Not covered" with a reason — never guessed.

**Hard rule — reuse vs replace.** The target's *structure, layout, information architecture,
design tokens, feature set, and behavior* may be recreated. Their *name, logo, brand assets,
verbatim marketing copy, images, model/product names, and legal text* must be **replaced with
original content**. Specs quote the original's copy only as a structural reference, with
REPLACE markers. Final legal text is always drafted fresh.

## Phase split — decide before starting

1. **Public recon (always).** Fetch-only: no browser needed. Robots/sitemap/llms.txt → page
   crawls → the **effect census** (every color, typography treatment, spacing value,
   shadow, gradient, mask, filter, transition, keyframe, pseudo-element system, and
   interactive state — automatically, from HTML + compiled CSS + chunks) → design tokens +
   micro-interactions → legal outlines → spec.
2. **App walkthrough (only if the site has a logged-in product and the user wants it).**
   Browser session in the main agent; user completes any login/OAuth/CAPTCHA themselves.
3. **Clone & apply (optional).** When the user wants a working clone, not just specs, build
   the flagship page(s) as a **1:1 replica** — tokens into a `:root`/`@theme` sheet
   unchanged, §4-style components, blueprint sections as markup, micro-interactions at the
   captured easings/staggers — under the asset policy (recreate structure exactly;
   procedurally generate or placeholder anything brand-owned). Then verify with a
   side-by-side screenshot comparison.
   **Pick the build strategy first** (`references/clone-build.md` §C0): on a prerendered
   page, transplant the target's own DOM (harvest per section, reattach tokens, replace the
   framework's JS with vanilla equivalents) — it reaches true 1:1 far faster and more
   accurately than re-typing markup from a blueprint. Hand-build only client-rendered
   shells. For a faithful replica kept strictly local, brand copy may stay verbatim when
   the user explicitly asked for a replica — say "local test only, not for deployment" in
   the README; anything that leaves the machine falls under the hard rule above.

   **A 1:1 replica reproduces:** exact hex/spacing/radii/shadow strings; exact typography
   per breakpoint; exact DOM/section order with captured aria names and testids; exact
   keyframes, easings, stagger patterns, scroll thresholds, and hover/active/focus states
   (`references/micro-interactions.md`); the same SSR-vs-client-render split; breakpoint
   behavior including mobile-only omissions (they are design decisions); ambient loops at
   the captured cadence; the same reduced-motion posture. It replaces only brand assets
   (procedural stand-ins) and — outside the local-replica exception above — verbatim copy
   and legal text (REPLACE pass).

**Autonomy rule — the user never names effects.** The effect census
(`references/effect-census.md`) is a mandatory Phase A step, not an optional one: sweep
every fetched page against the compiled CSS and inventory every visual on the site —
colors, typography treatments, spacing rhythm, shadows, gradients, masks, filters,
motion, states, pseudo-element systems, layering. The user never needs to send screenshots
or say "this site has X effect, copy it": when they point at anything later, it is already
in the effects inventory with its exact values. If the live site shows something the
census cannot explain, chase it to its chunk (or Phase B) before writing the spec — an
undocumented visual is a gap, and a gap becomes a tell in the replica.

Read the phase playbooks before executing:

- `references/public-recon.md` — fetch order, crawl discipline, token extraction, JS-chunk
  mining, and a ready dynamic-workflow template (`assets/recon-workflow.template.ts`) for the
  fan-out when the site is large.
- `references/css-extraction.md` — the full CSS/token extraction logic: collecting every
  stylesheet, reading custom properties (inline per-wrapper re-declarations, swapped naming,
  literals that bypass tokens), typography/weight/opacity ladders, shadow + radii stacks,
  motion variable families, per-instance component surface systems, provenance marking, and
  the paste-ready output format.
- `references/micro-interactions.md` — the micro-interaction & motion playbook: grepping
  compiled CSS for keyframes/easings/pseudo-element glow systems/reveal initial-state
  families, mining JS chunks for spring configs and interaction logic, the live-observation
  checklist (hover/scroll/streaming/ambient), the per-component interaction-state matrix,
  and the motion rules a 1:1 clone owes.
- `references/effect-census.md` — the exhaustive sweep that makes the skill autonomous:
  build the "used CSS" set, bucket every declaration (colors, typography, spacing,
  surfaces, effects, structure), census pseudo-states/pseudo-elements/at-rules, classify
  into the effects-inventory table, run the completeness gate, and finish clones with the
  replica-blind audit.
- `references/clone-build.md` — the 1:1 replica build playbook: strategy test
  (prerendered → markup transplant vs client-rendered → hand-build), DOM harvesting with
  `assets/split_landing.py`, Tailwind rebuild pitfalls (version detection, custom utilities,
  theme aliases for arbitrary values, the dark-mode trap + `@custom-variant`), asset
  localization, vanilla-JS replacement of framework behaviors (reveal systems, tabs,
  accordions), JS-chunk content mining, and the verification recipes.
- `references/app-walkthrough.md` — browser session protocol, login handoff, route probing,
  capture checklist, quota/checkout flows, mobile pass.
- `references/cognix-case-study.md` — the complete worked example: how the Cognix docs were
  produced (workflow recon → fact-check → browser walkthrough → specs) and how the clone was
  built from them (explain-first gate, procedural assets, screenshot comparison).
- `references/spec-format.md` — deliverable skeletons (§0–§10 public / §A–§K app) and the
  evidence rules.

## Explain before code (hard gate)

**Never start writing build code until the build is explained to the user in one message and
confirmed.** The explanation must cover, concretely:

1. **Token sheet summary** — the extracted `:root`/`@theme` values that will go into the
   stylesheet (colors with hex, type ladder, spacing/radii/shadows, motion), including any
   swapped naming and "fix in rebuild" items — plus the **micro-interaction summary**
   (keyframes, easings, staggers, hover/active states) that the clone must reproduce.
2. **Component inventory** — each component to build and which extracted spec defines it.
3. **Build order** — section-by-section for the page(s) being cloned, matching the
   blueprint's DOM order.
4. **Asset policy** — exactly what gets recreated vs replaced/procedurally generated
   (logo, imagery, icons, partner marks, copy).

The user's confirmation is the license to edit code. Then apply the extracted values
literally: same hex, same sizes, same easings, same shadows — judgment is spent on assets
and branding, never on "improving" measurements mid-clone.

## Operating lessons (learned the hard way — do not re-learn them)

- **Workflow subagents must stay fetch-only.** Browser automation (node_repl browser client)
  called from a dynamic-workflow subagent was permanently refused by the provider
  ("Method Not Allowed") and killed the run. All browser work happens in the main session,
  driven by you. Keep the two worlds separate.
- **Fetch-only is enough for design.** Most sites serve full HTML (test: does the homepage
  render its copy in `curl` output?). Tokens come from CSS custom properties, Tailwind
  patterns, and `font-face` rules — not screenshots. If the site publishes its own design doc
  (`/design.md`, `/branding`), treat it as ground truth and cross-check it against the CSS.
- **JS chunks are a spec goldmine.** Quota maps, plan prices (monthly figures often absent
  from SSR HTML), checkout endpoints and strings, signed-in plan states, hidden feature
  flags, model catalogs. Grep chunks for domain nouns ("workflow", "admin", "quota",
  "checkout", "plan") — and for on-demand content the prerendered HTML omits: accordion
  answers ship as *empty panels* and live in the chunk as template-literal pairs
  (`question:\`…\`,answer:\`…\``). Mine them at build time or the clone's accordions are blank.
- **On a prerendered page, transplant the markup — don't re-type it.** Harvesting the
  target's own DOM per section is the fastest accurate route to 1:1; re-typing from a
  blueprint guarantees drift. Split with an HTML parser (depth-tracked, auto-descending
  wrapper chains) and **keep each element's own tags** — a splitter that renders only
  children silently deletes `<header>`/`<a>` wrappers. Use `assets/split_landing.py` +
  `assets/skeleton.py` instead of reading minified HTML.
- **The dark-mode trap.** Static HTML often ships `<html class="dark">` (prerender
  artifact) while the app forces the opposite theme at hydration (grep the chunk for
  `classList.remove('dark')`). Tailwind v4 defaults `dark:` to the OS media query —
  without `@custom-variant dark (&:where(.dark, .dark *))` a dark-OS machine leaks dark
  styles (white-on-white headings). Also: copy the site's custom utilities verbatim and
  add `@theme` aliases for vars used inside arbitrary values (`--color-dots: var(--dots)`)
  or those utilities silently no-op.
- **Inline animation start states are a blank-page failure mode.** Prerendered sections
  ship `opacity:0` / `translateY(24px)` / `scaleY(0)` inline styles the framework animates
  away at hydration. A static transplant must reproduce that reveal system — and the
  filter must match **transform-only hiding** (`scaleY(0)` chart bars have no opacity) and
  carry a **timer fallback** per section, or the clone renders blank sections forever.
- **Headers leak architecture.** `x-middleware-rewrite` (internal routes), CSP `connect-src`
  (voice/realtime/storage/API providers), `x-powered-by`, permissions-policy, HSTS. Record
  them — a rebuild needs the same posture.
- **Behavioral route probing beats guessing.** Menu items that bounce to `/` = gated
  features (find the entitlement in pricing copy); hard fetch failures = edge-blocked admin;
  real 404s = dead links. One focused probe per candidate from robots.txt + UI facts, then
  stop.
- **Plan-state subtleties.** Sites may split *subscription* (what you pay) from *access
  tier* (what an admin assigned); their own pages can disagree. Admin-assigned tiers usually
  break real checkout (capture the failure toast — that IS the finding). Never pay; opening
  the checkout attempt and recording the result is enough.
- **Screenshots are for layout truth, DOM snapshots are for structure.** Capture
  screenshots at desktop + one mobile size (390×844); use DOM snapshots for copy, testids,
  and a11y names. Watch for mobile-only omissions (footer disclaimers, title dropdowns) —
  they are real design decisions. In clone verification: native full-page capture
  stitches `position:fixed` headers into artifacts — scroll through once, settle, then
  take viewport shots at offsets; screenshot the ORIGINAL early (continuous canvas
  animations make later automation time out); rAF throttling in automation browsers can
  hang Playwright stability checks on a clickable element — hit-test with
  `elementFromPoint`, then fall back to coordinate clicks.
- **Login is the user's hands, not yours.** OAuth + CAPTCHA steps are completed by the user
  in the visible browser; you drive everything before and after. Account creation, email
  verification, and payments are always the user's call — ask once, then execute.

## Deliverable contract

1. `<domain>-rebuild-spec.md` — public site: overview/stack, route map + IA, token sheet
   (paste-ready), **effects inventory** (the index of every visual on the site), motion &
   micro-interaction sheet, component library with interaction-state matrices, per-page
   blueprints with verbatim copy, feature inventory, legal outlines, issues/gaps,
   reuse-vs-replace, build milestones.
2. `<domain>-app-spec.md` — logged-in app: account/session facts, route map (verified vs
   gated vs blocked), shell & navigation, feature behaviors, settings taxonomy, theming,
   API/infra surface, quota/checkout, mobile layout, build-plan delta.
3. Cross-reference pointer paragraph in each file's "how to read" block; both files end with
   an explicit **Not covered** list with reasons (gated, blocked, client-rendered, would
   spend money/quota).
4. If a clone was approved: a working project with the extracted tokens applied 1:1, plus a
   README holding the **original-vs-clone screenshot pair** (hero + full page, stitched from
   viewport slices with `assets/stitch-pngs.mjs` if native full-page capture mis-renders) and
   an honest known-deltas list. When verbatim brand copy was kept for a local replica test,
   the README states "local test only, not for deployment".
5. If the project keeps a `context.md` (AGENTS.md protocol), append timestamped entries for
   the research batches and the deliverables.

## Execution order

1. Confirm scope with the user in one message: target URL, public-only vs app too vs full
   clone, login method (if app), and whether checkout may be *opened* (never paid). Then work
   without asking again — except at the explain-before-code gate.
2. Run Phase A (read `references/public-recon.md` + `references/css-extraction.md` +
   `references/effect-census.md` + `references/micro-interactions.md` first — the census
   drives the sweep). Deliver the public spec.
3. If app research is in scope: run Phase B (read `references/app-walkthrough.md` first),
   then write the app spec and add the cross-reference pointers.
4. If a clone is in scope: pick the strategy (`references/clone-build.md` §C0), **present
   the explain-before-code message** (tokens, components, build order, asset policy) and
   wait for the user's go-ahead, then implement — applying extracted values exactly (on
   prerendered targets, run the transplant pipeline: `assets/split_landing.py` → token
   reattachment per §C2 → `assets/skeleton.py`-guided vanilla JS per §C4) — and verify with
   the screenshot comparison (see `references/cognix-case-study.md` Stage 5 for the capture
   recipe and `references/clone-build.md` §C6 for the automation quirks).
5. Close: verification pass (re-open 3–4 key surfaces, compare against the spec), fill
   remaining cross-checks (quota numbers vs plan pages), final Not-covered audit, log the
   batch.
Pliki w paczce (16)
  • SKILL.md 16 KB
  • assets/accent-text.css 2 KB
  • assets/dither-canvas.tsx 4 KB
  • assets/dither-kit.mjs 6 KB
  • assets/recon-workflow.template.ts 14 KB
  • assets/skeleton.py 2 KB
  • assets/split_landing.py 6 KB
  • assets/stitch-pngs.mjs 5 KB
  • references/app-walkthrough.md 5 KB
  • references/clone-build.md 12 KB
  • references/cognix-case-study.md 5 KB
  • references/css-extraction.md 5 KB
  • references/effect-census.md 9 KB
  • references/micro-interactions.md 6 KB
  • references/public-recon.md 5 KB
  • references/spec-format.md 4 KB

Wersje

W bazie nie ma innych skilli o nazwie pixel-clone.

Migawka bazy z 13.11.2026 · wersja paczki 4286117257e0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100clone-website
    Odtwarza stronę internetową, wydobywając sekcja po sekcji zasoby, CSS i treść oraz uruchamiając równoległych agentów budujących w worktrees.
  • 100website-clone
    Odtwarza wygląd i zachowanie strony referencyjnej jako oryginalną witrynę z nowymi treściami i marką, sprawdzając zrzuty obok siebie.
  • 100superloopy-clone
    Odtwarza istniejącą stronę www jako implementację, zapisując specyfikacje komponentów, zasoby i wyniki wizualnej weryfikacji.
  • 100clone-website
    Przebudowuje istniejącą stronę w nową bazę kodu o tym samym wyglądzie i zachowaniu: przechwytuje strony, breakpointy, tokeny, zasoby i stany, buduje sekcjami i porównuje pixel diffem.
  • 100clone-team
    Klonuje stronę zespołem agentów AI (menedżer, frontend, backend, tester), który iteracyjnie buduje wierną kopię interfejsu i dokumentuje architekturę działania serwisu.
  • 100plagio
    Zapisuje design żywej strony, czyli komponent, całą stronę lub tokeny marki, jako specyfikację do odbudowy lub dopasowania nowego projektu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.