Your Free Website Builder Won't Let You Leave: How to Have an LLM Rebuild Your Site as Code You Own

Free website builders have a quiet business model, and it isn't the free tier. It's the day you want to leave. The template is proprietary, the content lives in their database, the "export" button — if one exists at all — is gated behind the paid plan or produces files that are half-garbage when you open them. You didn't build a website so much as you built an account on someone else's platform.

The good news: your site is sitting right there in a browser, fully rendered, and that's all the raw material an LLM agent needs. Instead of hunting for an export feature that doesn't exist, you point Claude at what your site actually is — markup, styles, images, structure — and have it regenerate the whole thing as plain code you host anywhere. This is the escape hatch that the export features won't give you, and it's mostly free.

This picks up where <code>The Website Builder Exit Plan: Exporting Your Design Before You're Locked In</code> left off. That post covered what each builder officially lets you export and what breaks when you use it. This one is for the situation where the official path is a dead end — where the export is paywalled, incomplete, or simply doesn't exist on your plan.

Why the export button was never the real answer anyway

Even where builders do offer exports, they're usually lying to you about what you're getting. Squarespace's WordPress export produces a content dump that loses most of your design. Wix famously offers no general export at all. Webflow exports code but not CMS content, and only on paid plans. In every case, what you get is a snapshot of content, not a working site.

But here's the thing the builders don't want you to internalize: everything they render in the browser is HTML, CSS, and image files by the time it reaches you. Their proprietary formats only exist server-side. The rendered page is public, readable, and — crucially — something an LLM is extremely good at turning back into clean, standalone code.

The rebuild loop: what you actually do

The process is less "migration tool" and more "supervised reconstruction." It works like this:

1. Capture the source material

For each page of your site, save the rendered HTML (in any browser: View Source, save the page as "Webpage, HTML Only," or use a single-page archiving tool like SingleFile). Also download your images — most builders serve them from predictable CDN URLs that are visible in the saved HTML.

You're not going to use these files directly. Saved builder HTML is a disaster: minified, full of framework boilerplate, tracking scripts, and class names generated by algorithms. You're using it as reference material, the same way you'd hand a contractor photos of your old kitchen.

2. Feed it to Claude and ask for clean reconstruction

This is where the LLM earns its keep. The prompt pattern that works:

Here is the saved HTML of a page built on a website builder.
Rebuild this as a single clean HTML file with embedded CSS.
Keep: the visual design, layout, text content, image placement,
and responsive behavior.
Drop: all tracking scripts, builder boilerplate, inline
framework code, and external dependencies except image URLs.
Use semantic HTML and modern CSS. Explain any section where
you had to guess at the original styling.

The last line matters. LLMs will silently fill gaps with plausible-looking guesses, and on a rebuild, a guessed navigation structure or a wrong typeface weight is exactly the kind of thing you want flagged, not smoothed over.

3. Iterate against the live site, side by side

Open your rebuilt version next to the original. The first pass will get you maybe 80% there — right structure, roughly right styling. The remaining 20% is a conversation: "the hero section should be full-width with the image darkened behind the text," "the mobile menu collapses to a hamburger below 768px." Claude handles these corrections well because it's working from its own output, not a black box.

For anything the saved HTML can't tell you — hover states, animations, what happens on click — check the live site yourself and describe the behavior. You are the bridge between the reference and the rebuild.

4. Repoint the images

Image URLs from the builder's CDN will keep working for a while, but they're the first thing to break when you finally cancel. Download the images, put them in an /images folder, and have Claude rewrite the paths. This is a five-minute fix that saves you a future site full of broken pictures.

Where MCP changes the game

Doing the above manually works for a five-page site. If yours is bigger — or you'd rather not copy-paste HTML into a chat window twenty times — this is where the MCP setup from <code>Your AI Should Publish While You Sleep: Building an MCP Pipeline That Blogs on a Schedule</code> comes back into play, pointed at a different job.

An agent with browser access (via a Puppeteer or Playwright MCP server) can navigate your own live pages, extract the rendered markup and styles itself, and write the rebuilt files straight to a local folder or repo. A web-fetch-style MCP server can pull each page's HTML on request. The loop becomes: the agent fetches a page, rebuilds it, writes the file, moves to the next one — and you review the diff at the end instead of shuttling files by hand.

The same pipeline that lets Claude publish to your site can also be used to read from one. It's the same plumbing, running in the opposite direction.

What survives the rebuild — and what doesn't

Be honest with yourself about the trade before you start:

Survives well: static pages, text content, images, standard layouts, navigation, footers, most styling. This is the bulk of most small-business and portfolio sites.

Survives poorly: forms that post to the builder's backend (you'll need to swap in a form service like Formspree or Netlify Forms — both have free tiers), members-only content, e-commerce, anything driven by the builder's database. Dynamic features become static shells that you then wire to your own services, which is real work the LLM can scaffold but not finish for you.

Won't survive at all: your subscription. That's the point.

Where the rebuilt site goes

Anywhere, and that's the whole reward. Because what you end up with is plain files, every free-tier static host from <code>The $0 Website, Audited: What Building With AI Actually Costs When Every Tool Has a Free Tier</code> will take it: GitHub Pages, Netlify, Cloudflare Pages. No import tool, no compatibility check, no plugin. It's your code now.

One warning from the other side: once the site is portable, it stays portable. Run the version-control discipline from <code>Your AI Site Isn't Done, It's on Version One: The Safe Edit Loop for Sites Claude and ChatGPT Built</code> from day one of the rebuild — commit the original reconstruction before you start editing it, so you always have a known-good reference of what Claude produced.

The honest cost

Plan an evening for a small site: an hour of capture and first-pass rebuilds, another hour or two of iteration against the original. Larger sites scale roughly linearly, though the MCP-assisted version compresses that considerably. What you buy with that evening is permanent: files that no company can hold hostage, that any host can serve, and that any future LLM session can edit without asking a builder's permission first.

The free tier was never free — it was paid for in optionality. This is how you buy it back.