Skip to main content
skill CX Codex

clone-website · dembrandt — Claude Code skill: what it does, how to install

clone-website rebuilds a live page into Figma, Penpot or code with verification. Captures renders, styles and content from a real browser, assembles the layout section by section, and checks the result against the original.

MIT 411 installs ★ 197 updated 2026-10-22

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

What clone-website does

The skill captures the page at two widths (390 and 1440 pixels), extracts DOM, styles and content, downloads assets, and measures design tokens: type scale, palette, spacing. Then it assembles the layout section by section in the chosen tool, comparing each against the original before moving on.

Ten steps inside: browser render capture, raw HTML via wget, token extraction, content parsing, assembly in auto layout, triple verification (visual, structural, semantic), swapping stand-in fonts for licensed ones, and targeted fixes. Without FFmpeg and Playwright, pages with video and carousels will not capture fully.

Verification runs at three levels: does it look identical at both widths, is it built with containers or absolute positions, do the words and numbers match. The last separates a copy from a lookalike: token extracts from the original and the rebuild are compared, the difference is the remaining work.

What it helps with

  • capture a competitor page for teardown and token analysis
  • migrate a production page back into a design system for refactoring
  • verify that new markup matches an approved design
  • rebuild a landing page in Figma with measurements, not approximations

Example prompts for the agent

  • Clone stripe.com/pricing into Figma with token verification
  • Rebuild this landing page as React components, checking each section
  • Extract design tokens from this page and assemble it in Penpot

How to install clone-website

1Skills CLI (Vercel)

npx skills add dembrandt/dembrandt-skills --skill clone-website -a claude-code

2Manually: put the files in place

~/.claude/skills/clone-website/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/clone-website/

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

Questions about clone-website

How to install clone-website in Claude Code?

Run npx skills add dembrandt/dembrandt-skills --skill clone-website -a claude-code, then open ~/.claude/skills/clone-website/SKILL.md to verify.

What does clone-website do?

Captures a live page with render and styles, extracts design tokens, assembles the layout section by section in Figma, Penpot or code, and verifies the result against the original visually, structurally and semantically.

What does clone-website require to work?

Playwright for browser control, wget for markup download. Without FFmpeg, video and animations will remain empty placeholders.

Source text

SKILL.md · MIT
---
name: clone-website
description: Rebuild a live web page 1:1 from measurement into Figma, Penpot or code, then verify it. Use when reproducing a page or checking a rebuild against the original.
metadata:
  priority: 8
  promptSignals:
    phrases:
      - "clone this website"
      - "clone a page"
      - "copy this page"
      - "recreate this site"
      - "rebuild this page"
      - "website to figma"
      - "html to figma"
      - "import site into figma"
      - "pixel perfect copy"
      - "reverse engineer landing page"
      - "1:1 copy"
      - "teardown"
retrieval:
  aliases:
    - clone website
    - website to figma
    - html to design layers
    - rebuild a landing page
    - page teardown
  intents:
    - reproduce a live page as editable design layers
    - rebuild a competitor landing page for a teardown
    - migrate a production page back into a design tool
    - verify that a rebuild matches the original page
  examples:
    - clone stripe.com/pricing into Figma
    - rebuild this landing page as React components
    - turn this URL into editable layers
    - check whether my rebuild matches the original page
---

# Clone a Website, Accurately

One-click cloners return a lookalike: it resembles the page, and nothing in the
process ever checked whether it matches it. This skill produces a different
artifact — values traceable to the source, and a diff that says what is still
wrong.

**The one rule: if the page states a value, read it. If it does not, and only
then, decide it.** A rebuild done that way is finished when the diff is empty,
which you can check, rather than when it looks about right, which nobody can.

Only the rebuild step cares whether the target is Figma, Penpot or a codebase.
Everything else is the same job.

## Decide before you capture

- **Two widths are the design target**, 390 mobile and 1440 desktop. Real
  devices open the same page at other ratios, so these are what you design to,
  not what you will see.
- A site that follows the light and dark preference renders **two different
  pages**. Capture both, or say which one you copied.
- The IP, locale, consent state and A/B branch reach the site before you do, so
  **what you capture is one visitor's view**, not the page. Check from a second
  location before trusting prices or copy.

## 1. Capture the rendered page

Drive a real browser and take four things at once: full-page screenshots at
both widths, the rendered DOM, the computed styles of each section, and the
asset URLs the page requested. On a client-rendered page this is the only
capture that contains anything at all.

Rendered state is the specification, not the file the server sent.

## 2. Take the raw source as well

Markup carries text verbatim and names every asset URL without a screenshot in
the loop.

```bash
wget -r -l 3 -k -p -E -nc https://example.com/page
```

Host-spanning is left out on purpose: CDN assets stay unfetched, their URLs are
in the markup, and they get downloaded directly at step 4. `wget` does not run
JavaScript, which is why it is the second capture and not the first.

## 3. Measure the design values

Read the tokens off the live page rather than off a picture — the type scale,
palette and spacing are already declared. Use [[extract-design]] for the
extraction; `--design-md` gives you a brief you can hand straight to the
rebuild step.

## 4. Take content and images from the capture

Parse headings, body copy, numbers, lists, links and the footer out of the DOM,
then download every referenced asset. Never retype a string and never infer a
value the source states. Nothing retyped means nothing drifts.

## 5. Build section by section

One section at a time — header, hero, feature rows, tables, media, testimonials,
FAQ, footer — in auto layout or real layout containers, never pinned
coordinates. Screenshot each section and compare it before moving on. A rebuild
judged only at the end gets judged once, badly.

## 6. Compare three things, not one

| Check | Question |
|---|---|
| Visual | Does it look the same at each width? |
| Structural | Is it built from sane containers rather than absolute positions? |
| Semantic | Are the words, links, numbers and variants the ones the source states? |

The third is the one people drop, and it is the one that matters most. A
perfect visual copy can carry wrong data, and it will pass every screenshot
comparison you run against it.

Token-level verification is free: extract the original, extract the rebuild,
compare the two token sets. The difference is your remaining work, stated as a
list instead of a feeling.

## 7. Fix what the capture could not see

Some errors are structural blindness, not degradation, and none of them look
like errors:

- A hero using the wrong image because the real one is a CSS background.
- Carousel or video items in the wrong order.
- Two cards whose values differ by variant, copied from each other.

Report what you could not resolve rather than guessing.

## 8. Fonts: stand in, then swap

Licensed foundry fonts usually cannot be loaded in an automated environment,
and a visual lookalike is the wrong answer because it moves every line break
you are about to verify. Build on a metric-compatible stand-in, then swap to
the real face at the end with one find and replace.

## 9. Fix by targeted prompt, not by rerunning

Every remaining error is local, so the instruction has to be local too: name
the section, name what is wrong, name the source value. Rerunning the whole
rebuild to fix one card costs the hour again and moves the errors somewhere
new.

Where the fix is a judgement call rather than a value, produce two or three
versions of that one section and ask which is right — and ask what made it
right. That sentence is what gets applied to the next section instead of a
guess.

## 10. Throw the scaffolding away

Import gone, staging assets gone. What is left is the two frames, named layers,
icons as vectors, not one absolutely positioned element. If the import is still
in the file, the file is still a draft.

## What this is for

Reproducing a page is research: teardowns, redesign baselines, migration
references, and regression checks against your own site. The last is the most
undervalued — the fastest way to learn whether production still matches its
design system is to extract it and compare.

Shipping someone else's layout, copy or brand as your own is a different act,
and the pipeline being fast does not make it a better idea. Respect robots.txt
and terms of service.

## Related

- [[extract-design]] — the measurement step, and the verification pass
- [[generate-ui-from-brand]] — when the goal is new UI in a brand, not a copy
- [[authentic-product-representation]] — keeping rebuilt content truthful

© dembrandt · MIT · dembrandt/dembrandt-skills

Similar skills

All skills for Design →

clone-website by other authors comes first.

clone-website coco-research clone-website replicates target web pages into a self-contained single-file HTML prototype without build tools. Handy when you need to inspect or recreate UI layouts quickly. CX Codex +1 ★ 328repo stars d2c d2c-ai d2c turns Figma frames into frontend code built on your own components and tokens, then checks the result against the design. ★ 8repo stars taste Senlin A skill for Claude Code and other platforms: dissects any website's design from a URL, extracts tokens (colors, fonts, grid) and reasoning into .md and .json. Triggered by /taste <url> or a phrase like 'analyze vercel.com's design'. CX Codex +1 707installs extract-design Manavarya09 The extract-design skill analyzes a website URL and generates files describing its design system. Use it to bring a site's colors, typography, and component patterns into a project. CX Codex +1 3,500installs figma heygen-com Pulls Figma designs into HyperFrames videos: assets, brand tokens, components, shaders and motion. Imports freeze at build time, renders never call Figma. CX Codex +1 466,500installs design-system-patterns Seth Hobson The design-system-patterns skill for Claude Code covers token architecture, theming, and component patterns. It activates for token creation, theme switching, and component-library foundations. CX Codex +1 15,953installs build-design jakubkrehel build-design builds UI code from a Figma file or image mockup. It reuses existing project tokens and components instead of hardcoding values. CX Codex +1 11,100installs

From the same set45

The whole set →
coordinated-data-views coordinated-data-views — a coding-agent skill that explains how to show a table next to its map, diagram or chart and keep selection synced both ways. CX Codex +1 843installs tab-navigation tab-navigation — a skill for designing tabs: when they fit, how the strip and panel are built, and how keyboard navigation should behave. CX Codex +1 842installs authentic-product-representation authentic-product-representation enforces truthful product visuals on landing pages and hero sections using real data instead of lorem ipsum. Use it to avoid synthetic marketing chrome. CX Codex +1 831installs domain-expert-configuration domain-expert-configuration is a Claude Code skill that guides settings panel design for people who know the problem domain but not the codebase. It activates on prompts about configuration, constraints or solver settings. CX Codex +1 830installs app-shell app-shell is a Claude Code skill with design guidelines for top bars, app switchers, tenant indicators, and status bars. It keeps navigation consistent across internal tools and customer portals. CX Codex +1 504installs sizing-units sizing-units teaches the agent to pick CSS units by intent: rem for text, px for borders, relative units for containers. CX Codex +1 437installs surface-separation surface-separation — a skill that teaches the agent to separate cards, panels and containers by one method — border, shadow or fill — and reserve opacity for states. CX Codex +1 378installs marketing-vs-product-system marketing-vs-product-system separates brand token foundations from surface-level UI decisions when a marketing site and a product app share one codebase. CX Codex +1 373installs

Project sponsors

Companies that keep this analytics open