Use AI to plan your website, draft website text, create code prompts, review quality, and prepare a launch — with a site you can understand, adjust, and maintain yourself.
Share this page
A good AI-built website still needs human decisions: the goal, the audience, the page structure and the quality bar. This guide keeps the workflow static-first and reviewable, so AI speeds up the work without creating a codebase nobody understands.
Honest scope: this is a practical website-building workflow, not legal, security or business advice. Use qualified humans for contracts, regulated industries, payment flows and sensitive data.
Start with the job of the website. A one-page tool, local service page, portfolio and SaaS landing page need different content and navigation.
Choose one primary action. Sign up, contact you, use a tool, read a guide or buy.
Write the promise in one sentence. The website should make that promise obvious.
Decide what not to build. Every extra feature adds maintenance.
Try it yourselfWebsite goal prompt - Replace the highlighted words, then send it to ChatGPT
Help me define the goal of a simple website. The project is [describe project]. The main audience is [audience]. The main action I want visitors to take is [action]. Give me: 1) one clear value proposition, 2) the minimum pages needed, 3) what to avoid building at the start, and 4) the most important trust signals.
Step 2
Plan the pages
Before writing code, create a small sitemap and decide what each page must answer. This prevents AI from generating random sections that look nice but do not help users.
Home: what it is, who it helps, where to start.
Core pages: one clear intent per page.
Support pages: privacy, disclaimer, imprint or contact where needed.
Try it yourselfWebsite sitemap prompt - Replace the highlighted words, then send it to ChatGPT
Create a simple sitemap for [website idea]. Keep it small and static-first. For each page, give me: page goal, H1, short meta description, key sections, primary CTA, and internal links to related pages. Avoid duplicate pages and avoid thin content.
Step 3
Choose the technical setup
A simple website should be boring in the best way: readable HTML, focused CSS, minimal JavaScript and a hosting setup that is fast by default. For many small sites, a static-first setup is enough: your pages are files, not a heavy app that needs a server for every visitor.
Register a domain with a registrar such as GoDaddy, Namecheap or Cloudflare Registrar.
Use GitHub for version control. You get a history of every change and a safe way to roll back.
Deploy to a global content delivery network (CDN). Cloudflare Pages or GitHub Pages can serve static files close to visitors and issue HTTPS automatically.
Keep runtime logic small. Use JavaScript for interaction, not for rendering content that could be static HTML.
Prompt for AI Programming Skills
My project is an "initial Google landing page load" website.
You are working on a highly optimized frontend website with a focus on:
- maximum Google PageSpeed scores
- minimal CLS, LCP and TBT values
- clean long-term architecture
- as little unnecessary JavaScript as possible
- as little unnecessary CSS as possible
- stable layouts without layout shift
- a professional, maintainable codebase
- modern SEO best practices
- minimal third-party impact
- static-first architecture
- as little runtime logic as possible
- minimal DOM complexity
The website uses:
- vanilla JavaScript
- static HTML files
- responsive layouts
- dark mode
- critical CSS optimization
Important architecture principles:
1. Architecture is more important than minification.
- Do not blindly minify everything.
- HTML should remain readable.
- JS and CSS may be production-oriented and compact, but not aggressively minified.
- The DOM structure should remain clean and understandable.
2. Performance is more important than framework comfort.
- No unnecessary JavaScript.
- No unnecessary rendering.
- No unnecessary event listeners.
- No unnecessary reflows or repaints.
- Minimize third-party impact.
3. Optimize the critical rendering path.
- Above-the-fold content should render with as little CLS as possible.
- Critical CSS should only cover layout stability and first paint.
- Load non-critical CSS later when appropriate.
- Avoid unnecessary blocking resources.
4. Treat third-party scripts with extreme care.
- If AdSense, Analytics or a CMP are used, load them as late and efficiently as possible.
- Use only necessary preconnects.
- Every additional request must be justified.
- Avoid unnecessary Google or tracking dependencies.
5. CSS principles:
- No unused rules.
- No duplicate rules.
- Group components logically.
- Keep global side effects as small as possible.
- Use efficient selectors.
- Keep only necessary dark-mode rules.
- When minifying CSS, do not remove the space between [data-theme="dark"] and :is(...), because that breaks dark mode.
6. JavaScript principles:
- Separate state, rendering and behavior clearly.
- Do not keep legacy helpers.
- Do not keep dead logic.
- Avoid unnecessary DOM builders.
- Prefer event delegation.
- Prefer progressive enhancement.
7. SEO and semantics:
- correct canonicals
- clean hreflang architecture
- semantic HTML
- stable heading hierarchy
- no SEO placeholders
- content should be as static as possible
8. For every change:
- think about architecture first
- then performance impact
- then maintainability
- only then implement
- always list the changed files
9. Core principle:
Do not stop at “it works.” Check whether the change:
- is truly best practice
- reduces runtime cost
- reduces CLS
- reduces parsing
- reduces DOM complexity
- reduces third-party impact
- improves long-term maintainability
10. Work extremely carefully.
- No unnecessary changes.
- No layout regressions.
- No aggressive automatic minification.
- Respect the existing working architecture.
- Keep changes minimal and targeted.
Technical rule of thumb: build the smallest version that can be fast, understandable and maintained. Add complexity only when a real user need requires it.
Step 4
Create copy and visuals
Once the structure is clear, generate page copy and image prompts. Keep visible text in HTML, not baked into images, so it remains accessible, translatable and indexable.
Try it yourselfLanding-page copy prompt - Replace the highlighted words, then send it to ChatGPT
Write landing-page copy for [website idea]. Audience: [audience]. Primary CTA: [CTA]. Tone: [tone]. Include: hero headline, subtitle, three benefit sections, one trust section, FAQ, and footer microcopy. Keep the language clear, useful and not hype-driven.
Step 5
Build the first version
Ask AI for small, reviewable changes instead of a full rewrite. One page, one component or one issue at a time is easier to test and safer for performance.
Keep the DOM simple. Fewer elements usually means less CSS and fewer layout surprises.
Reserve image space. Use width, height and aspect-ratio to avoid cumulative layout shift.
Prefer static content. Text that should rank in Google belongs in HTML.
Before you paste code live: read it, test it on mobile and desktop, and keep a backup of the last working version.
Step 6
Audit before launch
Before going live, review the site from four angles: code quality, search visibility, Googlebot rendering, and real user clarity. Separate the audits so each prompt stays focused and the feedback stays actionable.
For a useful audit, download your current project as a ZIP file and upload it to the AI tool together with the matching prompt. For rendering and performance reviews, also capture a HAR file from Chrome DevTools: open DevTools, switch to the Network panel, reload the page, then export the recorded requests as HAR. A normal webpage link cannot safely open DevTools directly in a visitor browser, so use the official Chrome DevTools HAR export guide when you need step-by-step instructions. Review HAR files before sharing them because they can contain URLs, cookies or other sensitive request data.
Audit prompts
Code Quality Audit
You are a conservative senior frontend code auditor for a static vanilla-JS website with critical CSS and dark mode. If present, also consider AdSense, GA4, Cookiebot and Cloudflare.
IMPORTANT:
- Do not fix anything yet. Do not rewrite files.
- Do not make assumptions without saying so. Only report concrete project-specific findings with file and line/selector.
- This project is edited by multiple AI tools, so actively look for inconsistencies between sessions.
Check systematically:
1. HTML
- invalid HTML, tag balance, duplicate IDs, missing labels or alt text
- wrong semantics, unnecessary div nesting
- missing lang/meta/charset/viewport
- consistency of identical blocks such as nav, footer and theme loader across all pages
2. Critical CSS, which is critical for this project
- Does inline critical CSS contradict external CSS?
- Are there above-the-fold layout-stability or CLS risks?
- Is the critical CSS enough for first paint without layout jumps?
3. CSS
- duplicate or unused rules, redundant media queries
- too much specificity or !important misuse
- inconsistent spacing, sizes or widths between page types
- dark mode coverage: hardcoded colors, correct data-theme selectors, missing components
- style rules that need to be kept in sync across files
- shared CSS that belongs in the shared file instead of duplicated page CSS
4. JavaScript
- likely bugs, dead functions, duplicate logic, global variables
- event-listener leaks, unnecessary DOM queries and reflows
- event delegation versus individual listeners
- progressive enhancement: does the page still work without JavaScript?
- missing error handling
- JavaScript controlling layout widths that should be handled by CSS
5. Third parties
- AdSense, GA4 and Cookiebot loading timing and consent gating
- only necessary preconnects; every request should be justified
6. UX and responsiveness
- mobile issues, overflow, touch targets and layout breaks
- navigation and hamburger behavior across all page types
7. Accessibility
- keyboard use, focus states and contrast in light and dark mode
- aria, forms and labels
Consistency check, main focus:
- Do similar pages differ in width, font size, spacing or structure without a reason?
- Are there components or styles that drifted apart between tools or sessions?
Output format:
## Executive Summary (max 5 sentences)
## Findings
For each problem: Priority (Critical/High/Medium/Low) · File:line · Area · Problem · Why it matters · Risk of changing it · Minimal fix
## Inconsistencies between pages/tools
## Copies that must be kept in sync
## Quick Wins (< 10 min)
## Safe Fix Order (safest first)
SEO Review
You are a senior technical SEO auditor for a static website.
IMPORTANT:
- Do not change anything yet.
- Do not give generic tips.
- Only report concrete findings in the existing code, with file and page/URL.
Check systematically:
1. On-page SEO
- title per page, ideally around 50 to 60 characters
- meta description, ideally around 150 to 160 characters
- duplicate titles and descriptions across all pages and languages
- keyword relevance and content hierarchy
2. Headings
- exactly one H1 per page
- logical H2/H3 structure
- no heading-level jumps without a reason
3. Technical SEO
- canonical tags: present, absolute and self-referencing
- hreflang: reciprocal, x-default present, valid language codes
- robots.txt and sitemap.xml: URLs match real pages, all important pages included, status/redirect risks
- indexability, accidental noindex, URL structure
4. Content
- thin or duplicate content
- missing context
- internal linking depth, orphaned pages and CTA structure
5. Images
- alt text
- descriptive filenames
- file sizes
- lazy loading
- LCP image should not be lazy-loaded
6. Social and structured data
- Open Graph fields
- Twitter Card fields
- Schema.org JSON-LD: syntactically valid, fitting @type, BreadcrumbList present where useful
- breadcrumb names match visible breadcrumbs
7. Core Web Vitals and SEO impact
- render-blocking CSS/JS
- critical-CSS conflicts
- CLS risks from missing image dimensions, late fonts or injected ads
- identify the likely LCP element
Output format:
## Executive SEO Score (1–10)
## Critical problems with ranking impact only
## All Findings
For each problem: Priority · File · Page/URL · Problem · SEO impact · Minimal fix · Expected benefit
## hreflang / i18n Findings
## Quick Wins
## Priority Roadmap (Top 10 by ROI)
User Experience Review
Task: UX, SEO and conversion review with best-practice research for this website: [INSERT URL]
Review the page from three perspectives:
1. User experience and user guidance
2. SEO and content structure
3. Conversion, marketing and activation of new users
Important: For every point, do a short web-based best-practice check. Recommendations should not be based only on gut feeling, but compared with examples, benchmarks or recognized UX, SEO and conversion principles.
The goal is not to implement immediately. First create a shared evaluation. After review and agreement, the prioritized points can be implemented.
1. Stronger primary call to action on the homepage
Check whether the most important starting point on the homepage is clear enough.
From a user perspective, it should be immediately clear:
- What can I do here?
- Where do I start?
- What do I get after the first click?
Research:
- best practices for hero sections on SaaS, tool and AI websites
- best practices for primary and secondary CTAs
- examples of good CTA wording for free AI tools
Possible hypothesis to test:
A prominent button such as “Create your first prompt”, “Start with a prompt generator” or “Build your first AI prompt” could activate users faster.
Give a recommendation:
- Is the current CTA sufficient?
- Which CTA wording is best from a marketing and SEO perspective?
- Which variant should be tested?
2. Guided entry through a simple start question
Check whether new users should be guided more clearly.
Idea:
On the homepage or a central generator page, ask:
“What do you want to do with AI?”
Then show 6–8 clear tiles, for example:
- Write or improve an email
- Summarize text
- Translate something
- Create an image prompt
- Plan a trip
- Explain a document
- Generate social media content
- Build a custom prompt
Research:
- best practices for guided onboarding
- best practices for tool selection through use cases
- conversion examples from AI tools, prompt libraries and SaaS websites
- whether use-case-based navigation works better than category-based navigation
Give a recommendation:
- Which use cases should be shown prominently?
- How many tiles are useful?
- Where should this entry point be placed?
- Should it be added to the existing navigation rather than replacing it?
3. Universal Generator: Quick Mode versus Expert Mode
Review the Universal Prompt Generator from a user perspective.
Hypothesis:
The generator is powerful, but beginners may see too many fields at once.
Check whether it should be split into:
- Quick Mode / Simple Mode: few required fields, fast output
- Expert Mode / Advanced Mode: all existing detail fields
Research:
- form UX best practices
- progressive disclosure in complex forms
- conversion impact of long forms
- examples of AI tools with simple and advanced modes
Give a recommendation:
- Which fields are truly necessary for beginners?
- Which fields should be optional or collapsible?
- How can the generator keep its power without overwhelming new users?
4. Concrete example directly in the hero area
Check whether the homepage should show an immediately visible before/after example.
Idea:
Basic input:
“Write my email”
Better prompt:
“Write a polite follow-up email to a client who has not replied for 7 days. Keep it professional, short, and friendly. Include a clear next step.”
Research:
- best practices for demo examples above the fold
- examples of AI tools that show value with before/after demos
- whether concrete examples can improve conversion
Give a recommendation:
- Should an example be placed in the hero?
- Which use case is best?
- Should the example be static, interactive or a mini-demo?
5. Do not reduce the existing navigation, validate and optimize it
Do not primarily check how to remove navigation. Instead, check:
- Is the current navigation understandable?
- Are the terms clear?
- Is the order logical?
- Are there too many equally important items?
- Is there a better grouping?
- Does it work well on mobile?
Research:
- navigation best practices for content and tool websites
- SEO effects of header navigation and internal linking
- mobile navigation best practices
- examples of websites with many tools or categories
Give a recommendation:
- What should stay?
- What could be grouped?
- Which menu items are important for SEO?
- Which menu items are most important for users?
6. Make trust, privacy and credibility more visible
Check whether existing trust elements should be more visible.
Positive signals already present:
- No account needed
- Privacy information exists
- Imprint exists
- No storage of user prompts according to privacy information
Research:
- best practices for trust signals on free tools
- privacy communication for AI tools
- how to communicate privacy benefits without overloading the page
Give a recommendation:
- Which trust notes should be visible on the homepage?
- Where should they be placed?
- Which wording is clear and trustworthy?
7. SEO and marketing review of the site structure
Review the current site structure from an SEO and marketing perspective.
Focus:
- Are the most important use cases covered as dedicated SEO landing pages?
- Are there clear keyword targets per generator?
- Are title tags, meta descriptions, H1/H2 structures and internal links optimal?
- Are there duplicate-content risks?
- Is there more organic traffic potential through long-tail keywords?
Research:
- current SEO best practices for tool websites
- SEO for programmatic pages / generator pages
- SEO for AI prompt tools and prompt libraries
- best practices for internal linking between tool, tutorial and use-case pages
Expected output:
1. Finding per point
2. Best-practice insights from web research
3. Concrete recommendation
4. Implementation effort estimate
5. Priority: High / Medium / Low
6. Risk or dependencies
7. Measurable success metric
Example KPIs:
- primary CTA click-through rate
- Universal Generator usage
- homepage bounce rate
- scroll depth
- time to first generated prompt
- number of started generator flows
- organic clicks from Google Search Console
- ranking improvements for relevant keywords
Process:
1. Run analysis and best-practice research
2. Document recommendations
3. Review with me
4. Agree on prioritized points
5. Implement with IT/programming and SEO/marketing
6. Measure the most important KPIs after implementation
Goal: Improve the first user experience, clarity, SEO performance and use of the prompt generators without unnecessarily hiding the existing navigation or losing SEO value from the current structure.
Googlebot Rendering Review
You are a hybrid SEO, UX, rendering and Googlebot auditor.
IMPORTANT:
Do NOT behave like a normal user.
Analyze the website primarily from the perspective of:
1. Googlebot
2. Google rendering pipeline
3. Core Web Vitals
4. information retrieval and semantic relevance
5. crawlability
6. indexability
7. internal link structure
8. above-the-fold UX
9. E-E-A-T signals
10. likely ranking efficiency
Think like:
- Google Search quality systems
- a technical SEO auditor
- a rendering engine
- a semantic parser
- a UX and conversion optimizer
- a crawl-budget optimizer
Do NOT think like a designer.
Do NOT think like a marketing copywriter.
Do NOT judge only by Lighthouse.
-----------------------------------
TASK
-----------------------------------
Analyze the following website completely:
[INSERT URL]
Run a full audit.
Evaluate:
- HTML structure
- DOM structure
- rendering behavior
- JavaScript dependencies
- crawlability
- semantics
- above-the-fold area
- information hierarchy
- internal linking
- content density
- layout spacing
- visual prioritization
- loading behavior
- lazy loading
- hydration problems
- CLS risks
- mobile UX
- accessibility signals
- semantic relevance
- indexing risks
- possible quality or spam signals
- trust and E-E-A-T
- PageRank distribution within the page
-----------------------------------
IMPORTANT BEHAVIOR
-----------------------------------
Assume:
- Google does NOT scroll like a real user
- Google usually does not actively click around
- content behind scroll events, clicks, hover effects, tabs, accordions or JS-only rendering may be indexed less reliably
Check therefore:
- which content is present in the initial HTML
- which content only appears after JavaScript
- which content Googlebot might miss
Consider:
- crawl budget
- rendering cost
- DOM complexity
- unnecessary JavaScript execution
- high hydration cost
- infinite-scroll risks
- missing crawlable URLs
- weak internal linking
- weak semantic signals
-----------------------------------
ANALYSIS STRUCTURE
-----------------------------------
Create the audit in these sections:
1. Executive Summary
- largest SEO and rendering problems
- largest ranking opportunities
- most critical errors first
2. Googlebot Rendering Analysis
- What does Google see immediately?
- What does Google probably NOT see?
- Which content is risky?
- Which content depends too much on JavaScript?
3. Above-the-Fold Analysis
Evaluate:
- visibility of the main message
- spacing and whitespace
- H1 position
- CTA visibility
- content density
- semantic clarity
- rendering priority
- visual hierarchy
- possible UX or SEO issues
Check explicitly:
- too much whitespace
- important content too far down
- unnecessary animations
- hero sections without informational value
4. Core Web Vitals and Performance
Evaluate:
- LCP
- CLS
- INP
- TTFB
- JS size
- render blocking
- hydration cost
- lazy-loading problems
- image optimization
- font loading
Explain:
- which issues are truly ranking-relevant
- which issues are only Lighthouse cosmetics
5. Information Architecture
Evaluate:
- semantic structure
- heading hierarchy
- topic clarity
- internal linking
- crawl depth
- important page prioritization
- topic-cluster quality
6. Semantics and Content
Check:
- semantic clarity
- search intent
- thin content
- entity signals
- keyword cannibalization
- duplicate risks
- E-E-A-T
- expertise and trust signals
7. Mobile-First Analysis
Evaluate:
- mobile prioritization
- above-the-fold on mobile
- tap targets
- mobile rendering problems
- content shift
- mobile speed
8. Technical SEO Analysis
Check:
- SSR versus CSR
- HTML quality
- schema markup
- canonicals
- meta tags
- robots
- sitemap
- pagination
- infinite scroll
- indexing problems
- crawl problems
9. Prioritized Actions
Group all recommendations into:
- CRITICAL
- HIGH IMPACT
- MEDIUM IMPACT
- LOW PRIORITY
Explain:
- why this likely affects ranking
- why this helps Googlebot
- why this improves UX
10. Quick Wins
List the 10 fastest improvements with maximum SEO, UX and rendering impact.
-----------------------------------
VERY IMPORTANT
-----------------------------------
Be critical.
Be technical.
Be precise.
Do not provide:
- generic SEO clichés
- marketing fluff
- superficial tips
Provide:
- real rendering problems
- real crawl problems
- real semantic problems
- real UX and layout problems
- real ranking levers
Where possible:
- explain concrete causes
- explain concrete effects on Google
- explain concrete technical solutions
Evaluate the website from the perspective of a modern Google rendering system of the latest generation, not from classic SEO checklists from 2018.
Code quality: HTML validity, CSS structure, JavaScript, accessibility, dark mode, Core Web Vitals, layout stability, maintainability, and safe refactoring.
SEO: titles, meta descriptions, headings, canonicals, hreflang, internal links, schema, images, crawlability, duplicate-content risks, and long-tail opportunities.
User view: clarity, trust, CTA strength, mobile friction, cognitive load, navigation, first-click confidence, and conversion path.
Tip: Fix High-priority issues first. Do not refactor working code just because AI suggests a cleaner pattern.
Step 7
Launch and improve
Publish the site, watch what happens and improve in small steps. A website is never finished; it becomes useful through feedback, measurement and careful iteration.
Check the basics: mobile layout, links, forms, analytics, privacy pages and page speed.
Measure one or two goals: CTA clicks, generator starts, scroll depth or contact clicks.
Iterate carefully: small changes are easier to test and easier to roll back.