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
How to prompt Gemini: specific instructions, stated constraints, a few examples, and the question after the context.
Gemini is Google's AI assistant and the family of models behind it. You may meet it as a standalone app, as a helper built into Google's productivity tools, or through the developer API. The surface changes what it can see, such as an open document or files you attach, but the way to ask for good work stays much the same.
Google's prompt design documentation treats prompting as an iterative process. You are not expected to get it right on the first attempt. Start with a clear instruction, look at what comes back, and adjust: rephrase, add an example, change the order of the parts. That framing is worth adopting, because it turns a disappointing answer into information about what the prompt was missing.
A Gemini prompt generally has up to four ingredients: the task, any constraints on how it should be done, the context or source material, and the format of the response. Leaving one out is the usual cause of generic output. If you do not say how long the answer should be or who it is for, the model has to guess.
Standing guidance has its own place. Developers set system instructions that apply to a whole session; in the app, saved instructions and reusable custom assistants play a similar role. Use these for a persona, a house style or rules that should hold across many requests, and keep one-off details in the prompt.
Gemini accepts more than text. Images, documents and other files can be part of a prompt, and the same principles apply: say what the file is and what you want done with it.
Version names, limits and pricing are omitted here because they change. Which features you have depends on your account and region.
Google's documentation starts with the basics: say exactly what you want done, and state any limits on the response, such as length, scope or things to exclude. A prompt that says 'summarize this' leaves the model to decide how short and for whom. One that asks for three sentences for a non-technical reader removes the guesswork and gives you something to check the answer against.
The prompt design guide recommends few-shot examples as a strong way to control format, phrasing and scope, and suggests including them wherever practical. Keep the structure of every example identical, including labels and spacing, because inconsistencies can be picked up as part of the pattern. Showing what to do generally works better than showing examples of what to avoid.
Google advises adding the information required to solve the problem directly to the prompt: the document, the data, the background on your situation. Instructions can then tell the model to rely on that material. This is particularly useful for anything specific to your organization, where a general-purpose model would otherwise fall back on generic knowledge that may not apply.
When a prompt contains a large document or several files, the documentation suggests placing the material first and the specific instruction or question after it. A short bridging line, for instance one that refers back to the information above, helps anchor the request to the supplied content. The same ordering is used in most prompts on this site that take pasted source text.
The guide describes labeling parts of a prompt with prefixes, such as a marker before the input and another before the expected output, so the model can tell them apart. You can also start the response yourself, for example by writing the first row of a table or the opening key of a JSON object, and let the model continue in that pattern.
For tasks with several distinct stages, Google recommends breaking the work into simpler prompts, either as a sequence where each output feeds the next or as parallel pieces combined afterward. Rules that should apply throughout, like a role or a tone, belong in system instructions or their app equivalent, so they do not have to be repeated at each step.
These prompts are expected to work with Gemini 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.