Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

clone-site

/clone-site

Klonuje dowolną stronę z adresu URL do wiernej kopii w Next.js: rozpoznanie, wyciągnięcie zasobów i CSS, równoległe budowanie sekcji, port animacji i automatyczna weryfikacja zgodności.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
24.08.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
2
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
3
Przestarzałość

Brak sygnałów. Repozytorium zmienione 24.08.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ą
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/fidelity-diff.py

Co robi i kiedy

Klonuje dowolną stronę z adresu URL do wiernej kopii w Next.js: rozpoznanie, wyciągnięcie zasobów i CSS, równoległe budowanie sekcji, port animacji i automatyczna weryfikacja zgodności.

Wyzwalacze z opisu

make me a version oft say the word. Also triggers on

Argumenty

/clone-site <url> [<url2> ...] [notes like 'landing page only' or 'always animate']
Oryginalny opis (EN)

Clone any website from a URL into a pixel-faithful Next.js codebase — recon, asset/CSS extraction, parallel section builders, animation porting, and automated fidelity verification. Use whenever the user pastes a URL and asks to clone, copy, replicate, rebuild, reverse-engineer, or "make me a version of" a website or landing page — even if they don't say the word "clone". Also triggers on "/clone-site <url>". For multi-page sites it discovers and clones every page via the sitemap.

Jak działa

  1. Phase 0 — Project setup
  2. Phase 1 — Stack detection (decides everything)
  3. Phase 2 — Download the ground truth (source-first path)
  4. Phase 3 — Foundation (do this yourself, not via agents)
  5. Phase 4 — Parallel build
  6. Phase 5 — Verify (don't skip; this catches what eyeballs miss)
  7. Phase 6 — Register in the inspo hub
  8. Judgment calls to surface to the user (don't silently decide)
  9. Completion report
Sekcje z nagłówków SKILL.md, w oryginale · 109 linii, 1 444 słów
Podgląd SKILL.md
---
name: clone-site
description: Clone any website from a URL into a pixel-faithful Next.js codebase — recon, asset/CSS extraction, parallel section builders, animation porting, and automated fidelity verification. Use whenever the user pastes a URL and asks to clone, copy, replicate, rebuild, reverse-engineer, or "make me a version of" a website or landing page — even if they don't say the word "clone". Also triggers on "/clone-site <url>". For multi-page sites it discovers and clones every page via the sitemap.
argument-hint: "<url> [<url2> ...] [notes like 'landing page only' or 'always animate']"
---

# Clone Site

Reverse-engineer the site(s) at `$ARGUMENTS` into a Next.js codebase. This skill encodes a refined version of the ai-website-cloner-template pipeline: the big lesson is that **most marketing sites are static (Astro, plain HTML, SSR), and for those the served source IS the ground truth** — downloading it beats hand-measuring computed styles every time. Only fall back to browser-side style extraction for true SPAs.

Default scope: every page in the site's sitemap, pixel-perfect, with real assets and working interactions. If the user scopes it down ("just the landing page"), honor that.

## Phase 0 — Project setup

1. Create the project OUTSIDE any repo you're currently in:
   ```bash
   git clone --depth 1 https://github.com/JCodesMore/ai-website-cloner-template.git ~/Desktop/<hostname>-clone
   cd ~/Desktop/<hostname>-clone && rm -rf .git && git init -q && npm install
   ```
   If the folder exists, ask before overwriting.
2. Make research dirs: `docs/research/<hostname>/`, `docs/research/components/`, `docs/design-references/`.
3. Check `~/Desktop/inspo/sites.json` (the inspo hub — the permanent home of all finished clones, private repo `caezium/inspo`): if this site was already cloned, ask whether to redo it or extend the existing one. The Desktop folder is a workspace; the clone isn't done until Phase 6 registers it in the hub.

## Phase 1 — Stack detection (decides everything)

`curl -sS <url>` and inspect:

- **Content-complete HTML** (real headings/copy in the response; `_astro/` assets, or no root `<div id="root|__next">` shell) → **source-first path** (rest of this skill).
- **SPA shell** (empty root div, content materializes from JS) → the template's browser-extraction pipeline is the right tool; follow `.claude/skills/clone-website/SKILL.md` inside the scaffold (screenshots + `getComputedStyle()` extraction per section). The verification and parallel-builder phases below still apply.

Record: framework, stylesheet links, inline `<style>`/`<script>` blocks, font links, animation libraries (grep for `gsap`, `ScrollTrigger`, `lenis`, `framer`).

## Phase 2 — Download the ground truth (source-first path)

All into `docs/research/<hostname>/`:

1. **Every page**: fetch `sitemap.xml` (or `sitemap-index.xml`) for the definitive URL list. No sitemap → crawl nav/footer links one level. Save each page's HTML.
2. **Every stylesheet** — including page-specific ones (Astro emits per-page CSS files; different pages reference different ones).
3. **Every behavior script** — inline AND external `<script type="module">`. These minified files are the exact spec for animations; you will port them, not guess.
4. **Every asset** to `public/`: write a small Node download script. Sources of asset URLs: `<img src>` AND **every `srcset` variant**, `<video src/poster>`, CSS `url()` refs, favicons, webmanifest, OG images. Missing a `srcset` variant means broken images at other viewport widths — grep the HTML for all of them.
5. Take reference screenshots with Chrome MCP at 1440px (scroll through, screenshot each viewport-full) and note per-section behavior: what pins, what fades, what's tabbed vs scroll-driven. Two traps:
   - **Lazy images look blank** during fast programmatic scrolling — a blank card usually means `loading="lazy"` hadn't fired, not a real gap. Confirm via DOM (`naturalWidth > 0`) before "fixing" anything.
   - **`prefers-reduced-motion`**: if macOS Reduce Motion is on, both the original and your screenshots may show the static branches. Check `matchMedia('(prefers-reduced-motion: reduce)')` and read the source scripts for `reduce` gates so you know which animations exist even if you can't see them.

## Phase 3 — Foundation (do this yourself, not via agents)

1. **CSS verbatim**: concatenate all downloaded CSS + inline `<style>` blocks into `src/app/globals.css`, stripping framework scoping attrs (e.g. `[data-astro-cid-*]`). Keep the original class names. Do NOT translate to Tailwind — every translation step is drift risk, and fidelity beats idiom. Identical duplicate rules across per-page CSS files are harmless.
2. **Fonts**: replicate the original's Google Fonts `<link>` (or download self-hosted fonts). The CSS references literal family names, so `next/font`'s renamed families would break it — plain `<link>` in `layout.tsx` is correct here.
3. **layout.tsx metadata**: title, description, favicon, OG image from the original head.
4. `trailingSlash: true` in `next.config.ts` if the original uses trailing-slash URLs.
5. Install animation libs the site uses (`npm i gsap` etc.) — port to the npm package, never vendor the minified bundle.
6. Write `docs/research/PAGE_TOPOLOGY.md` (section map, interaction model per section) and `BEHAVIORS.md` (exact mechanisms from the de-minified scripts: trigger points, easings, durations, media-query gates). These are the builders' bible.

## Phase 4 — Parallel build

Split the page into sections (hero, nav, feature blocks, footer, modals...). For each, write a brief spec in `docs/research/components/<name>.spec.md`: target file, ground-truth fragment path, interaction model, behavior notes, gotchas.

Dispatch parallel builder agents (Agent tool, `general-purpose`), ~4–7 at once. Worktrees are unnecessary **if each agent owns disjoint files** — pre-write shared files yourself and forbid agents from touching them. Every builder prompt includes:

- Ground-truth fragment path + spec path + BEHAVIORS.md reference
- Conversion rules: strip scoping attrs; `class`→`className`, `srcset`→`srcSet`, camelCase SVG attrs, self-closing tags; **text verbatim — including apostrophe/quote style** (don't "fix" straight quotes to curly or vice versa; it shows up in the fidelity diff)
- "All CSS already exists in globals.css under the original class names — write NO new CSS, NO Tailwind"
- Port behaviors from the actual source scripts (de-minify), as hooks with cleanup; respect the original's media-query/motion gates unless the user asked otherwise
- "Only create/modify your own target files"; verify `npx tsc --noEmit`
- Ask builders to REPORT deviations and shared-component mismatches they notice — they catch real fidelity bugs (per-page CTA text variants, footer blocks present only on some pages)

Cross-component dependencies: use composition (`<Hero>{<HeroCard/>}</Hero>` via children) so agents never import each other's unfinished files.

**Multi-page sites**: extract shared chrome (Nav/Footer/Modals) into components with variant props FIRST — then per-page builders reuse them. Grep every page for the differences before assuming they're identical: nav light/dark variant, CTA label, `aria-current`, footer link blocks. Pages sharing one template (blog posts, comparison pages) batch 5 per agent.

Assemble `src/app/page.tsx` (and routes) yourself; run `npm run build` after merging.

## Phase 5 — Verify (don't skip; this catches what eyeballs miss)

1. `npx tsc --noEmit` and `npm run build` — must be clean.
2. `npx next start -p 3210` and run the bundled text-fidelity diff:
   ```bash
   python3 scripts/fidelity-diff.py --research docs/research/<hostname> --base http://localhost:3210
   ```
   (Copy `scripts/fidelity-diff.py` from this skill's directory into the project.) It strips tags/scripts, decodes entities, and reports missing words per page. Target ≥99%; chase every gap to root cause — real omissions vs entity-encoding artifacts vs apostrophe-style drift all look different in the output.
3. Live QA with Chrome MCP: side-by-side against the original at the same scroll positions; click every interactive element (tabs, accordions, toggles, modals); check the console for errors. Verify scroll-pinned sections actually pin (`.pin-spacer` exists, body height grew).
4. Capture a real homepage screenshot of the CLONE for the hub card — the template's stock `docs/design-references/comparison.png` is a demo image, not your site; delete it:
   ```bash
   "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless --disable-gpu \
     --screenshot=docs/design-references/clone-home-1440.png --window-size=1440,900 \
     --hide-scrollbars --virtual-time-budget=12000 http://localhost:3210/
   ```
5. Commit with a summary of sections/components/assets. No AI attribution in the message.

## Phase 6 — Register in the inspo hub

Every finished clone gets consolidated into `~/Desktop/inspo` (gallery of all clones; `sites.json` is the single source of truth — `index.html` renders purely from it, no other wiring).

1. Snapshot the code:
   ```bash
   rsync -a --delete --exclude node_modules --exclude .next --exclude .git \
     ~/Desktop/<hostname>-clone/ ~/Desktop/inspo/sites/<id>/
   git -C ~/Desktop/<hostname>-clone bundle create ~/Desktop/inspo/histories/<id>.bundle --all
   ```
   `<id>` = short lowercase name (see existing ids in sites.json).
2. Add a `sites.json` entry: `kind: "nextjs"`, `port` = next free 31xx, `thumbnail` = the real clone screenshot from Phase 5 (never a stock/template image), 3–5 design-vibe `tags` (reuse existing tag vocabulary where it fits), `description` = one line on the design language, `original_url`, and `run: "./serve.sh <id>"`.
3. Verify: `cd ~/Desktop/inspo && ./serve.sh` → the new card renders with its thumbnail at localhost:4600. Then commit + push (`origin` = private `caezium/inspo`).
4. Ask the user whether to delete the Desktop working folder. Before any deletion: check no other session is actively developing it (uncommitted work, recent commits you didn't make, running dev servers) — the hub snapshot captures files, not in-flight work. The history bundle preserves the git log either way.

## Judgment calls to surface to the user (don't silently decide)

- **Reduced motion**: if the original gates animations on `prefers-reduced-motion` and the user's OS has it on, the clone will look "broken but faithful". Default to matching the original's code; if the user reports missing animations, offer the always-animate override (drop the gates, comment the deviation).
- **Backend endpoints** (`/api/download`, form posts): a static clone can't replicate them. Keep the original URLs/actions and say so in the completion report.
- **Analytics** (PostHog, GA): strip them; note it.

## Completion report

Sections built, components created, assets downloaded, routes generated, build status, fidelity-diff scores, interactions tested, known gaps (backend routes, uncloned linked pages), and hub registration (sites.json id + port, pushed to caezium/inspo).
Pliki w paczce (2)
  • SKILL.md 11 KB
  • scripts/fidelity-diff.py 3 KB

Wersje

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

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

Pobrania w ostatnich 30 dniach: 1 · 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.
  • 91webcloner
    Klonuje wizualny projekt strony internetowej, odtwarzając landing, stronę marketingową, portfolio lub sklep w Next.js, bez aplikacji z logowaniem i dashboardów.
  • 100superloopy-clone
    Odtwarza istniejącą stronę www jako implementację, zapisując specyfikacje komponentów, zasoby i wyniki wizualnej weryfikacji.
  • 90clone-website-guide
    Prowadzi autoryzowane odtwarzanie stron z adresu URL, w tym użycie szablonu ai-website-cloner-template JCodesMore do nowego projektu, przy prośbach o odtworzenie wyglądu strony.
  • 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.
  • 100reverse-engineer-and-rebuild
    Odtwarza działającą stronę, aplikację lub API na podstawie adresu URL albo dostarczonego pliku i porównuje oryginał z kopią.

Uwagi i zgłoszenia

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