Complete Website Design Prompt
A structured brief that walks an AI model from business goals to sitemap, page layouts, visual direction and responsive rules.
- ChatGPT
- Claude
- Gemini
OpenAI
How to prompt ChatGPT: clear instructions, the right context, and standing preferences set once instead of repeated.
ChatGPT is OpenAI's general-purpose assistant. Most people use it as a chat window, but how well it performs depends less on clever wording than on three ordinary things: whether it knows what you want, whether it has the material it needs, and whether you told it what the finished answer should look like.
Instructions reach ChatGPT at two levels. Standing guidance, such as custom instructions in your settings or the instructions attached to a project or custom GPT, applies to every conversation it covers. The message you type applies to the task in front of it. Putting stable preferences (your role, your audience, the tone you want, formats you never want) in the standing layer keeps individual prompts short and stops you from retyping the same preamble.
Context works the same way. You can paste text, attach files, or keep reference documents in a project, and the assistant will work from them. It cannot work from material it has not been given, and when a prompt leaves a gap it tends to fill that gap with something plausible. Supplying the facts yourself, and saying what to do when information is missing, is the most reliable way to reduce invented detail.
The prompts in this library are written as structured text with labeled sections because that format suits this product well: OpenAI's own guidance recommends separating instructions from reference material with clear delimiters. Paste a full prompt for work that matters, and use the short version when you only need a first pass.
This page deliberately avoids version names, limits and prices, which change often. Feature availability also varies by plan and region, so check the product itself for what your account includes.
OpenAI's guidance distinguishes high-level instructions, which set how the model should behave throughout, from the user message that carries the specific request. In the ChatGPT app the equivalent is custom instructions or project instructions. Use that layer for things that are true of all your work: who you are writing for, spelling conventions, how long answers should be. Keep the task-specific detail in the message.
When a prompt contains instructions, background and source text, mark where each begins and ends. OpenAI's prompt engineering guide suggests Markdown headings and XML-style tags for this, so the model can tell an instruction from the material it is supposed to act on. This matters most when you paste a document: without a boundary, a sentence inside the document can be read as something you asked for.
Describing a format in the abstract is harder than showing one. The guide recommends few-shot prompting: include a small number of input and output pairs that demonstrate the pattern, and the model will usually follow it. Vary the examples enough that it picks up the pattern and not the surface wording, and say plainly if the examples are illustrative and should not be copied.
The guide advises including relevant context in the prompt, particularly information the model could not otherwise have, such as your own data, internal documents or recent decisions. Attach the file or paste the section. Then add a rule for gaps, for example asking it to list what is missing instead of assuming. That single instruction prevents a good share of confident but invented detail.
OpenAI's documentation notes that reasoning-oriented models respond well to a clear goal and constraints, with less need for a prescribed procedure, while other models benefit from more explicit, ordered instructions. In practice: if you have selected a thinking mode, state the outcome and the criteria for success. Otherwise, spell out the steps. If results disappoint, try moving in the other direction.
Say whether you want a table, a numbered list, plain paragraphs or a specific file type, how long it should be, and what to leave out. Format requests placed at the end of a prompt are easy for you to check and easy to adjust on the next turn. If the first reply is close, ask for the specific change instead of rewriting the whole prompt.
These prompts are expected to work with ChatGPT based on their structure. Check each prompt page for its testing status; see how compatibility is labelled.
A structured brief that walks an AI model from business goals to sitemap, page layouts, visual direction and responsive rules.
Reviews page markup against WCAG 2.2, separating issues confirmed in the code from those needing manual testing, with fixes and a test script.
Drafts design-system foundations: tiered design tokens, type and spacing scales, and component specs with variants, states and accessibility notes.
Plans a single-goal landing page: message match with the traffic source, section order, first-screen spec, form design and draft copy using only your real proof.
Turns one page layout into responsive rules: content order on small screens, fluid techniques, justified breakpoints and a per-component behavior table.
Runs a heuristic review of one user flow: a step-by-step walkthrough, findings tied to usability heuristics with severity ratings, and fixes.
Diagnoses an existing site from the evidence you supply, then plans what to keep, merge or remove, the new structure, a URL map and a phased rollout.
Produces a low-fidelity wireframe of one screen as a text diagram and block spec, with content priority, states and annotations and no visual styling.
Reviews a diff the way a careful senior engineer would: intent first, findings ranked by severity, each tied to a line with a suggested fix.
Works from your own field and lab data to rank likely causes of poor LCP, INP or CLS, with a way to confirm each one before you change code.
A plan-then-build prompt for App Router work: routes, server and client boundaries, caching, mutations and authorization, approved before any code.
Turns a description of your domain and consumers into a consistent REST contract: resources, endpoints, errors, pagination and open decisions.
Makes the model plan components, state and effects before coding, then deliver complete files, tests and a list of what it assumed.
Designs a relational schema from your entities, rules and real queries: relationships, DDL, constraints and indexes that each trace to a query.
Builds a layout with Grid, Flexbox and container queries that adapts to its content, with the reasoning and the edge cases to test.
Interviews you briefly, then drafts a reviewable spec: goals and non-goals, design, alternatives, rollout, risks and open questions.
Turns your own notes and experience into a focused blog post with one clear argument, and marks every spot where it needs a real example or a fact check.
Builds a section-by-section outline around one central question, with the evidence for each section and a list of what still needs research.
Analyzes your existing writing samples and derives a usable voice guide: traits with evidence, tone by situation, word lists and before-and-after rewrites.
Works out what a page must make the reader believe, then writes the copy in that order using only the proof you supply.
Drafts a customer case study strictly from the facts you supply, with every claim referenced and missing quotes or baselines listed.
Edits a draft at the level you choose, protects the author's voice, and returns a change log plus queries instead of silent rewrites.
Generates headlines from several distinct angles, checks each against accuracy and length tests, and recommends three with reasons.
Drafts a single work email that leads with the ask, suits the relationship, and leaves bracketed blanks for any detail you did not provide.
Turns seed topics and any keyword data you paste into intent-labeled clusters mapped to pages, without the model inventing search volumes.
Audits an existing page section by section, decides whether to refresh, rewrite, merge or leave it, and lists what to keep, update, cut, add and verify.
Builds an internal link plan from your page inventory: topic groups, hub pages and specific source-to-target links with anchor text, using only real URLs.
Reviews one existing page against its target query and returns specific before-and-after edits to the title, headings, opening, coverage, links and images.
Produces a writer-ready brief: reader intent, the angle only you can offer, a purposeful outline, evidence to gather and clear acceptance criteria.
Generates JSON-LD that mirrors what is visibly on your page, maps every property to its source text and refuses to add ratings or details that are not there.
Reviews crawl exports, URL lists and Search Console notes you supply, and returns evidence-backed findings ranked by impact with a fix and a check for each.
Writes unique, accurate title tags and meta descriptions for a batch of pages, with options, character counts and a check against what each page says.
Turns your business facts into a focused strategy: a diagnosis, one priority segment, positioning, three channels at most, and a phased plan sized to your budget.
Generates ad variations across four distinct angles, counted against your character limits, with every claim traced to proof you supplied.
Maps a welcome, nurture, cart or win-back sequence first, then writes each email with one job, one call to action and only the proof you supply.
Builds personas from the interviews, reviews or survey answers you paste in, tagging every line as evidence, inference or assumption.
A two-turn prompt: the model asks its key questions, then builds a launch plan with a message, dated timeline, readiness check, metrics and risks.
Plans two to four weeks of posts sized to the time you really have, built on content pillars and your own material, with week-one captions drafted.
Turns your idea, customer and known numbers into a structured plan draft, with every unverified figure flagged instead of invented.
Organizes the competitor information you have collected into a comparison, a positioning read and a list of what you still need to find out.
Builds a SWOT around a specific decision, ties each point to evidence you supplied, and converts the grid into strategic options.
Writes a clear, candidate-facing job post built around outcomes and a short must-have list, with hiring-manager notes on anything to check.
Drafts objectives and measurable key results from your priorities and current metrics, then audits its own draft for tasks disguised as results.
Produces a slide-by-slide deck outline with a one-sentence claim per slide, the proof behind it, and the questions your audience is likely to ask.
Summarizes a paper or report for a named reader: bottom line, method, key findings with exact figures, limits of the evidence, and what it means for them.
Produces a desk-research brief on a market, with segments, a range-based size estimate, competitors and pricing, and every figure labeled as sourced, provided or estimated.
Analyzes a pasted table or dataset step by step: data check, calculations with working shown, findings tied to those calculations, and what the data cannot support.
Turns the papers, abstracts and notes you paste in into an evidence table, themes and a synthesized draft, with every citation traceable to a source you supplied.
Writes a timed discussion guide for customer or user interviews: screener, opening script, behavior-based questions with probes, and a table tying each question to a learning goal.
Give the model the error, the code and what you expected. It ranks likely causes by evidence, tells you how to confirm each, and proposes a minimal fix.
Restructures code in small, named steps while holding its observable behavior fixed, and reports anything it could not prove equivalent.
A contract-first prompt: the model fixes the signature, types and error behavior of a function or module before it writes the implementation.
Turns a plain-language spec into a complete, typed Python script or module, with assumptions, run commands and edge cases listed separately.
Produces a case inventory first, then readable tests that check behavior at the boundaries, with suspected bugs flagged instead of encoded as passing.
A prompt that writes prompts: describe the image you need and get three detailed, copy-ready image-generator prompts plus notes for iterating.
Drafts a written identity system: color roles with contrast pairings, a type hierarchy, logo usage rules and imagery direction, tied to your positioning.
Writes a creative brief and three distinct logo concept directions in words, ready to hand to a designer or adapt for an image tool.
Converts a transcript or rough notes into decisions, owned action items and open questions, without assigning anything the meeting did not.
A two-round prompt: the model questions you first, then weighs your options against your criteria and argues against the one you already favor.
Checks your task list against the hours you really have, picks the few outcomes that matter and lays out a day-by-day plan with a cut list.
Plans one lesson around measurable objectives: a timed sequence, checks for understanding, likely misconceptions, adaptations and an exit ticket.
Writes a quiz from material you supply, using a blueprint, item-writing rules for fair questions and plausible wrong answers, and a separate explained answer key.
Builds a study guide from your own notes or readings: topic map, core content, commonly confused ideas, self-test questions with separate answers, and a revision schedule.
Writes a title, description, detail bullets and meta description from your product facts only, with a fact-check table and a list of what is missing.
Turns pasted reviews into counted themes with verbatim quotes, causes of complaints, customer language and recommendations graded by support.
Audits pasted product page content against the five questions a shopper asks before buying, with quoted evidence, severity, fixes and rewrites.