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
Anthropic
How to prompt Claude: explain the task as you would to a capable colleague, structure long inputs, and show examples.
Claude is the AI assistant made by Anthropic. It is available as a chat app, inside developer tools and through an API, and the same prompting habits carry across all of them.
Anthropic's documentation offers a useful mental model: write for a very capable new colleague who has no background on your project. That person would need to know what the work is for, who will read it, what a good result looks like and what to avoid. A prompt that answers those questions usually beats a short command, and it beats a long prompt stuffed with emphasis and repeated warnings.
There are two places to put guidance. A system prompt, or in the app the instructions attached to a project and your saved preferences, sets a role and standing rules. The conversation itself carries the task. Reference material can be pasted, uploaded, or stored as project knowledge so it is available in every chat within that project.
Claude handles long inputs well when they are organized. Anthropic recommends wrapping distinct parts of a prompt in XML-style tags, for example one tag around a contract and another around your instructions, so each part is unambiguous. The tag names are yours to choose; what matters is that they are consistent and descriptive. The labeled sections used in the prompts on this site serve the same purpose and can be converted to tags if you prefer.
For complicated work, one large prompt is not always the right tool. Splitting a job into a sequence, where the output of one step becomes the input of the next, makes each step easier to check and correct.
Specific model names, limits and plan features change frequently and are left out here on purpose. Anthropic's documentation is the place to confirm current details.
Anthropic's first recommendation is to be explicit about what you want and to supply context: the purpose of the task, the audience, and where the output will be used. Explaining why a constraint exists tends to work better than stating the constraint alone, because the model can apply the intent to cases you did not list. If you want thorough, detailed output, ask for it specifically.
The documentation describes multishot prompting, giving a few worked examples, as one of the most dependable ways to get consistent structure and style. Make the examples relevant to your real case and different from one another, so the pattern is learned and not a single instance. Placing them inside a clearly marked block keeps them from being confused with the instructions around them.
When a prompt mixes instructions, documents, data and examples, Anthropic suggests wrapping each in its own tag. This reduces the chance that pasted content is treated as a command and makes it easy to refer to a part by name later in the prompt. You can also ask for the answer inside named tags, which helps when you need to pull one section out of a longer reply.
Assigning a role, such as a contracts reviewer or a senior data analyst, focuses vocabulary, depth and priorities. Anthropic's guidance is to put the role and standing rules in the system prompt and keep task detail in the user turn. In the app, project instructions do this job. Keep the role specific to the work; a vague persona adds little.
Anthropic's long-context advice is to place lengthy documents near the top of the prompt and your instructions or question after them. When there are several documents, label each with its source so the answer can say which one a point came from. Asking for the relevant quotations to be extracted first, before the analysis, helps keep the response tied to the text.
The documentation recommends chaining for multi-stage work: research, then outline, then draft, then review, each as its own prompt with a single clear objective. Smaller steps are easier to inspect, and a weak stage can be rerun without redoing the rest. Asking Claude to review its own earlier output against your criteria is a legitimate link in that chain.
These prompts are expected to work with Claude 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.