Free Site Makers, Judged by One Question: Can You Plug an LLM Into Them Later?
Michael Sacca•Every "free site maker" review you've ever read asks the same questions. Is the drag-and-drop good? How many templates? Does the free tier put a banner on your site?
Those are fine questions if you're one person hand-assembling one page, once. They're the wrong questions if you're building a publishing pipeline — if the plan is that an LLM generates pages, an automation deploys them, and humans only show up to approve. In that world, the drag-and-drop is irrelevant, because nobody will ever drag anything. What matters is a single question:
Six months from now, can I point an LLM or a script at this site and have it make changes without opening the builder's editor?
That question splits the free-builder landscape into three clean buckets: platforms you can automate freely, platforms you can automate a little, and platforms where the editor is a locked room and the only key is a human with a mouse.
The test, made explicit
Before ranking, define what "plug an LLM into it" actually means. There are three levels, and they're not equivalent:
- Deploy from code. The site's source is plain files, and something can push new files and have the site update. This is the baseline — without it, nothing else is possible.
- API access to edits. The platform exposes a programmatic interface for changing content or configuration, so a script (or an LLM tool-calling through one) can make an edit itself.
- Room for the AI layer. The free tier lets you run your own glue — a scheduled script, a webhook, an MCP server that touches the site — without it counting against whatever the platform bills for.
A builder that fails level one can never be part of an automated pipeline, no matter how nice its free templates are. A builder that passes level one but nothing else is still workable, because — as covered in Your Site Is Live. Now Wire It to Claude: MCPs and Automations That Keep Editing It After Launch — most of the LLM-attached editing that matters happens outside the hosting platform, at the file level, with the host just serving whatever lands.
That's the reframe this whole post rests on: if your site is plain HTML in a repo, the automation lives in the repo, not in the host. The host only has to be dumb and reliable. This immediately reshuffles the rankings, because the builders that market hardest as "AI website builders" are often the ones you can automate least.
Tier one: static hosts, where the LLM writes and the host serves
GitHub Pages, Netlify, Cloudflare Pages, Vercel (free tiers) — these are the same category wearing different logos. Your site is files. Your LLM edits files. A push deploys. Everything above the file layer — page generation, copy swaps, variant creation — is yours to build with whatever model and MCP setup you like, because the platform has no opinion about how your files come to exist.
The practical difference between them, for this test, is mostly about deploy triggers. Netlify and Vercel will rebuild on every push to your repo; GitHub Pages serves straight from the branch. All three let a script be the thing that pushes. If your pipeline is "LLM writes page → script commits → site updates," all of them pass the full three-level test, and the choice between them comes down to features that have nothing to do with AI — build minutes, edge functions, team seats.
The honest caveat: these require you to be comfortable with a repo and a deploy step. That's friction the drag-and-drop builders don't have — which is exactly why the drag-and-drop builders can't pass this test.
Tier two: CMS-adjacent builders, automatable through their APIs
WordPress.com's free tier, and similar hosted-CMS offerings, sit in the middle. They expose REST APIs — WordPress in particular has a mature one — which means level two is achievable: a script can create and edit posts programmatically, and an LLM can drive that script. People have been auto-publishing to WordPress via its API for years; it's one of the oldest automation targets on the web.
The trade is different, though. You're no longer editing files; you're editing database records through someone else's API, with someone else's rate limits and auth model. Free tiers typically restrict which endpoints you can hit and how often. It works, but the automation is now coupled to the platform's API design, not to plain files. If the platform changes its API, your pipeline breaks in ways that never happen with static files.
Theme and template constraints also bite harder here. Your LLM can generate the copy and even the post content, but the page's structure lives in the theme, and themes are edited in the editor you were hoping to avoid.
Tier three: the drag-and-drop builders, where automation goes to die
Wix, Squarespace, and their peers are the builders most reviews rank first and this ranking puts last — not because they're bad, but because they're optimizing for a different user. The free tiers are built around one assumption: a human, in the editor, making each change.
They mostly have APIs at their upper tiers, but the free tiers generally don't, or restrict them enough that a generation pipeline has nothing to grip. And even where an API exists, the unit of edit is "the site object" — opaque, proprietary, and useless to an LLM that works in HTML and text. You cannot hand Claude your Wix site. You can hand Claude a screenshot and hope it writes good instructions for you to click through manually, which is not automation, it's transcription.
This mirrors the finding in Landing Page Builders That Accept Your Own Code (and Which Force a Rebuild) — the same split between builders that accept outside material and builders that demand everything be born inside their editor applies doubly when the outside material is generated at runtime.
One nuance before the Wix loyalists write in: some of these platforms have launched their own AI site-generation features. That's beside the point here. The question isn't "does the platform have AI" — it's "can your AI, your pipeline, your model of record touch the site." A built-in generator that produces a site once is level zero of this test. It automates the first build and nothing after, which is precisely the part this blog has argued is the easy part.
The decision, compressed
So here's the ranking, judged by the only question in the title:
| Can an LLM or script edit it later? | Verdict |
|---|---|
| Static file hosts (GitHub Pages, Netlify, Cloudflare Pages, Vercel free tiers) | Fully — files are the API |
| WordPress-style hosted CMS free tiers | Partially — via their content APIs, with coupling and limits |
| Wix/Squarespace-class drag-and-drop free tiers | Effectively no — the editor is the only interface |
The uncomfortable implication: the "free site maker" that best supports automation is not a site maker at all. It's a file host. The builder-shaped part of the job moves up into your pipeline — page templates the LLM fills, a commit script, an MCP server — which is more setup, but it's setup you own.
If that sounds like more than you want to take on, the middle tier is a legitimate compromise: generation of content automated through a CMS API, structure handled by a human occasionally opening the editor. It's the realistic floor for most small teams.
But if you're starting from zero today, start with the question in the title, not the template count. The free builder you pick determines whether "the LLM maintains the site" is a pipeline you build once, or a decision you have to reverse in six months — and reversals always cost more than the template you liked. If you're weighing the zero-dollar stack as a whole, Build a Website Free With AI: The Zero-Dollar Stack, What You Get, and What Breaks First covers the economics; this post covers the part most reviews never ask about: what the free tier lets you attach later.