Back to HTML Pub

Before You Deploy: The 12-Point Checklist for Code ChatGPT or Claude Handed You

Michael Sacca•
AI-Native Publishing
Landing Pages
Debugging

There's a particular kind of confidence you get from a code block in a chat window. It looks complete. It runs, more or less. The buttons are where they should be and the headline is the right shade of blue. So you copy it into a folder, connect your host, hit deploy — and spend the next hour discovering that the form silently does nothing, the mobile menu never opens, and the page that loads on your phone is a completely different animal from the one in Claude's preview.

None of this means the model failed. It means AI-generated code has a failure profile all its own, and it's predictable enough to check for. Every post on this blog covers what happens after the code exists — where to host it, how to get a domain on it, what to do when the pixel won't fire. This is the step before all of that: the audit you run between "Claude wrote it" and "it's live."

Here are the twelve checks, roughly in the order you should run them.

The five that break the page

1. Scripts loading in the wrong order

LLMs love to reference a library — jQuery, a slider, an animation library — in the <head> while the script that depends on it sits lower in the body, or vice versa. Or they call a function on page load that targets elements the script hasn't rendered yet. Open the browser console (right-click → Inspect → Console) and reload. Any red text there is a script that ran and failed. AI-written pages almost always have at least one.

2. Event handlers attached to elements that don't exist yet

The classic version: your JS is in the <head>, the button it's binding to is at the bottom of the <body>, and the code runs before the button exists. The fix is either moving the script to the end of the body or wrapping the logic so it waits for the page to load. If you can't diagnose it yourself, paste the console error back into the chat and ask the model to fix its own ordering — it's very good at this when handed the exact error.

3. Forms with no destination

A form that renders beautifully and submits to nowhere is the single most common defect in AI-built landing pages. The model writes the HTML markup for the form but has no idea where the data should go, so it either leaves the action attribute empty or points it at a placeholder. Static hosts don't process forms at all, so "it works in preview, submits nothing in production" is normal, not a bug in your setup. We've covered the actual solutions — form services, serverless endpoints, CRM webhooks — in Your AI Landing Page Gets Traffic — But Where Do the Leads Go?. Check that the form has a real destination before deploy, because a broken form looks identical to a working one until someone fills it out.

4. Half-formed CSS at the breakpoints

The desktop view Claude generates is usually excellent. The mobile view is where models hedge — media queries that stop at one breakpoint, a flex layout that collapses into a single column but never checks what that column looks like at 320px. Resize the browser window manually, all the way down to phone width. Don't trust the model's own preview pane; many of them render at a width no real phone has.

5. Assets that exist in the chat, not on the disk

Images referenced as /images/hero.jpg that were never created. Fonts loaded from a URL that requires attribution. Icons that are inline SVG in the demo and missing entirely in your copy of the code. Do a search through your files for src= and href= and confirm every referenced path actually exists.

The four that break how the page is found

6. The title tag and meta description

Ask an LLM for a landing page and you'll often get a <title> of "My Website" or nothing at all. The <meta name="description"> is missing more often than it's present. These are what search engines and social platforms display, and they take thirty seconds to fix. Write them yourself — you know the offer better than the model's placeholder does.

7. Open Graph tags

Without og:title, og:description, and og:image, every link you share on social or in a text message renders as a bare URL with a random snapshot. If you're building landing pages with AI and planning to run any traffic to them, this is non-negotiable — the preview card is doing conversion work before the page even loads.

8. The favicon request

Small, but it shows up as a 404 in your console forever and looks unprofessional on a browser tab. Add one or explicitly suppress the request.

9. Placeholder content that made it into production

"Your headline here." "Lorem ipsum dolor sit amet." "[email protected]." Models generate these as scaffolding and expect you to swap them, and the ones hiding in alt text, form labels, and footer copyright lines are the ones you miss. Ctrl+F for "placeholder," "lorem," "example," and "your" across the whole project.

The three that break the business, not the page

10. Conversion tracking — present but not firing

The meta pixel and GA4 snippets the model pastes in are usually syntactically correct and functionally dead: fired before consent, fired on the wrong event, or blocked by the same script-ordering problem from check #1. This one deserves its own full treatment, and it got one — Claude Built the Landing Page. Now the Pixel Won't Fire: A Conversion-Tracking Setup for AI-Generated Pages walks the whole debugging path. But the checklist version is: after deploy, trigger the conversion action yourself and confirm the event appears in the platform's test tools before you spend a dollar on traffic.

11. Hardcoded secrets

If your page involves any API call — a form service, a map, a chatbot widget — check that no API key got pasted directly into client-side code. Anything in the HTML is public the moment you deploy. Keys belong in environment variables on the server side or in a service that's designed to be public-facing. Ask the model directly: "is there any secret, key, or credential in this code?" It will usually confess.

12. The canonical URL and the domain you actually bought

AI-generated code often references a generic domain or leaves hreflang and canonical tags pointing at a guess. If you've gone through the work of picking a domain and a host — and if you're reading this blog, you probably have, possibly via the scoring framework in AI Domain Hosting Is a Feature Set, Not a Host: The 5 Requirements Your AI-Built Site Actually Needs — make sure the code agrees with reality. A canonical tag pointing at the wrong domain tells search engines your real site is a duplicate.

Make it a script, not a memory

The nice thing about all twelve checks is that they're boring and repeatable, which makes them perfect for automation. Two ways to run them:

Let the model audit itself. Before you deploy, paste the full code back into the chat with a prompt like: "Review this HTML for: scripts that load out of order, forms without a working destination, missing meta and Open Graph tags, placeholder text, and any hardcoded credentials. List every issue with the specific line." The model is notably better at finding these defects when asked by category than when asked "is this good?"

Automate the mechanical half. The W3C's Markup Validator catches malformed HTML, unclosed tags, and invalid attributes in seconds — free, no account needed. Run every AI-generated page through it. Most of what it flags won't break anything, but some of it will, and it's the cheapest audit available.

The pattern behind the checklist

Notice what all twelve items have in common: none of them is about the code looking good. The model's output is almost always visually finished and functionally unfinished — because the chat window shows it a preview, but it can't click the button, submit the form, resize the window, or check the console. Only you can do that.

If you're building websites with AI as a repeatable workflow rather than a one-off, formalize this: save the checklist, run it every time, and the marginal cost of shipping an AI-built page drops to nearly zero. That's when the approaches in Stop Sending Every Ad to the Same Landing Page: How Many Pages You Actually Need (and How Claude Makes Each One in 20 Minutes) become practical instead of theoretical — twenty-minute builds are only cheap if the failure mode isn't an afternoon of post-launch debugging.

Run the twelve checks. Then deploy.

Keep Reading