How to Build a Personal Website with ChatGPT in 5 Minutes

No HTML. No hosting setup. No design skills. Just a prompt and a clone button.

The old way is broken

Open any "how to build a personal site with ChatGPT" tutorial from 2024 and you'll find the same shape: ask GPT to generate HTML, paste it into a file, push to GitHub Pages or Vercel, wait for DNS, fix CSS that broke on mobile, repeat. It's a four-hour project disguised as a five-minute one.

The real bottleneck isn't your time. It's that GPT is generating 3,000 tokens of HTML when all you wanted was "a clean portfolio with a hero, my projects, and a contact link." Every revision triggers another full regeneration. Every regeneration introduces new bugs. The token cost is brutal, the iteration loop is slow, and the output looks like 2014.

This guide takes a different path. Instead of generating HTML, you'll have ChatGPT generate a small JSON page description that an AI-native renderer turns into a polished site. The whole loop takes five minutes the first time and thirty seconds on every edit after that.

What you'll need

A ChatGPT account (free tier works fine — same for Claude, Gemini, Grok)
Three minutes of bio you can paste in
That's it. No Git, no terminal, no CSS.

Step 1 — Pick a theme

Go to moldpage.dev/themes and skim the six available looks. Each one is a distinct visual personality:

Golden Hour — warm, editorial, designer-friendly
Sterling — clean, professional, banker-grade
Aurora — vibrant gradients, creative work
Bloom — soft pastels, lifestyle / wellness
Ink — minimal black-and-white, writers
Neon — high-contrast, builders / engineers

Click any theme's demo page. Note the URL — you'll need the page ID (the slug after /view/) in step 3.

Step 2 — Prompt ChatGPT

Open a fresh ChatGPT conversation. Paste this prompt, then drop your bio in at the bottom:

You are generating a Mold page. Mold is an AI-native web protocol —
JSON instead of HTML. Output ONLY valid JSON, no prose, no markdown
fences.

Schema:
{
  "title": "string (page title)",
  "theme": "golden-hour | sterling | aurora | bloom | ink | neon",
  "sections": [
    {
      "id": "hero",
      "type": "hero",
      "props": { "headline": "...", "subhead": "...", "cta": "..." }
    },
    {
      "id": "about",
      "type": "text",
      "props": { "heading": "...", "body": "..." }
    },
    {
      "id": "projects",
      "type": "grid",
      "props": {
        "heading": "Selected Work",
        "items": [
          { "title": "...", "description": "...", "url": "..." }
        ]
      }
    },
    {
      "id": "contact",
      "type": "contact",
      "props": { "email": "...", "links": [{ "label": "...", "url": "..." }] }
    }
  ]
}

Pick the theme that best matches the person's vibe. Be specific in
copy — no generic "passionate about technology" filler. Aim for
voice, not LinkedIn-speak.

Here's the person:
[PASTE YOUR BIO HERE — 3-5 sentences about who you are, what you do,
what you're proud of, what you want]

ChatGPT will return a JSON block. Copy it.

Why this prompt works

Three things make it reliable:

Schema-first. GPT doesn't have to guess what fields are valid — they're listed. This eliminates the "AI invents fake props that don't render" failure mode.
"Output ONLY JSON." Without this, GPT loves to add explanatory paragraphs that break the paste-in step.
Voice instruction. "No generic filler" actually works — try the same prompt with and without that line and compare the output.

Step 3 — Clone the demo

Go to moldpage.dev/clone. You'll see a form with two fields:

Source page ID — the slug from the theme you picked (e.g. banker-demo for Sterling)
New page ID — pick a slug for yourself (e.g. your-name)

Submit. You now have your own copy at moldpage.dev/view/your-name with an edit token you should save somewhere safe.

Open the edit panel at moldpage.dev/edit?id=your-name&token=[your-token] and paste in the JSON ChatGPT gave you. Save. Your site is live.

Step 4 — Edit in plain English

Here's the part that breaks every other "AI site builder" tutorial: revisions.

In the old workflow, "change my hero headline" means regenerating the entire HTML, hoping nothing else breaks, and re-uploading. In the AI-native workflow, you have two options:

Option A — use the edit panel. Click the section, change the field, save. Done. Zero tokens spent.

Option B — ask ChatGPT for a patch. Open the same conversation and say:

Give me the JSON patch to change the hero headline to
"Building tools that respect your time" — only output the
section object, not the whole page.

GPT returns ~50 tokens of patched section. Paste that one section into the edit panel. Save. Total cost: pennies.

This is the difference between AI-assisted website building (slow, expensive) and AI-native website building (fast, cheap). The protocol is built around small surgical edits, not full page rewrites.

Common pitfalls

"ChatGPT added markdown fences around the JSON"

Strip the leading ```json and trailing ``` before pasting. Or add to your prompt: "Do not wrap the output in markdown code fences." GPT-4 and later usually obey.

"The output has fake fields the renderer ignores"

Older models occasionally invent props like "animation" or "layout". They're harmless — the renderer just ignores them. If you want them gone, ask GPT to "use only the fields shown in the schema."

"It looks generic"

That's almost always a bio problem, not a model problem. Generic bio in → generic site out. Try this rewrite trick: instead of "I'm a software engineer based in Toronto," try "I build small fast tools for people who hate enterprise software. Currently shipping a portfolio builder that runs on JSON, not HTML." Specific verbs and specific objects always win.

"I want a section that doesn't exist in the schema"

Eleven section types ship by default (hero, text, grid, contact, quote, list, gallery, timeline, stats, faq, cta). If you need something else, the JSON schema is extensible — just ask GPT to invent a sensible structure and the renderer will treat unknown sections as collapsible text blocks.

How long this really takes

I timed it on three people last week — two non-technical, one engineer:

Run 1 (designer, no code): 4 min 30 sec from cold start to live site.
Run 2 (lawyer, no code): 6 min 10 sec — the extra time was deciding between Sterling and Ink.
Run 3 (frontend dev): 3 min 50 sec — he tried to read the JSON schema first, which slowed him down.

The five-minute number isn't marketing. It's median.

Why I built this

I wrote the long version in Why AI Needs a Native Web Protocol, but the short version is: every "AI website builder" I tried in 2024 either generated bloated HTML or trapped me in a proprietary visual editor. I wanted a format AI models could read, write, and edit natively — a 50-token patch instead of a 3,000-token rewrite — and I wanted it to be free and open.

That's Mold. The protocol spec, the engine, all six themes, the API — all of it lives at moldpage.dev. Free, no signup wall, no upsell. Try it with ChatGPT, with Claude, with Gemini, with whatever model you trust. Tell me what breaks.

— Gerald Yang Toronto, May 2026