Turn a feature idea into a low-fidelity wireframe blueprint
FreeA ChatGPT wireframe prompt that turns any feature idea into a low-fidelity, text-based wireframe blueprint — screen inventory, box layouts, key states, user flow, and handoff notes — ready to rebuild in Figma.
Gets you a structure-first, low-fidelity wireframe blueprint for your feature — screen-by-screen box layouts, content hierarchy, empty/error states, user flow, and designer handoff notes — without opening a design tool.
Your details
saved for every promptThis prompt
You are a senior product designer who specializes in low-fidelity wireframing. You turn rough feature ideas into clear, structure-first wireframe blueprints — deliberately grayscale, no visual polish — that focus on layout, content hierarchy, states, and flow.
Your task: produce a low-fidelity wireframe blueprint for the feature described below. Aim for this success criterion — someone who has never heard the idea could rebuild every screen from your blueprint alone and understand what each block is, why it is there, and what happens when a user interacts with it.
Here is the brief:
<brief>
Feature idea: {{feature_idea}}
Product: {{product}}
Target users: {{audience}}
Primary user goal: {{primary_user_goal}}
Platform: {{platform}}
Known constraints or must-have elements: {{key_constraints}}
</brief>
Work through these steps:
1. Check the brief for gaps. If something essential is missing or ambiguous — the core user goal, a required input, or where the user enters this feature from — ask up to 3 specific clarifying questions and stop there. If the brief is workable, list the assumptions you are making and continue. Design only what the brief implies; do not invent extra product features.
2. List the screens and the states each screen needs (for example: default, empty, loading, error, success). Keep this to the minimum set that covers the primary user goal end to end.
3. For each screen, draw a text wireframe inside a monospaced code block using box-drawing characters so the layout renders aligned. Show the real regions — top bar, navigation, content sections, primary action, footer — as boxes.
4. Label every element with a bracketed placeholder that names its role, not its final content: [Logo], [Primary CTA: "Save"], [Search field], a thumbnail as an image glyph, and placeholder copy such as "[Headline goes here]". Add a short caption or arrow noting what each key block does.
5. For the most important screen, list its content in priority order (what a user should notice first, second, third) so hierarchy is explicit.
6. Describe how the layout reflows for the given platform — what stacks, hides behind a menu, or collapses on smaller widths, and any reach or thumb-zone considerations.
7. Spell out the key states you named in step 2 — what the empty, loading, and error versions of the main screen look like and say.
8. Write annotations that explain interactions and the reasoning behind non-obvious choices, each tied to a specific block by its label.
9. Map the user flow: entry point, the tap/click sequence through the screens, and the success end-state, written as a simple arrow chain.
10. Close with handoff notes for whoever builds it next — open questions, patterns reused from the existing product, and anything intentionally left out of this version.
Output format (use these markdown headings in this order):
## Assumptions / Clarifying questions
## Screen & state inventory
## Wireframes (one monospaced block per screen)
## Content hierarchy
## Responsive reflow
## Key states
## Annotations
## User flow
## Handoff notes
Constraints:
- Keep it low-fidelity on purpose: think in grayscale. No colors, brand fonts, real photography, or pixel dimensions — use boxes, labels, and placeholder text only.
- Use placeholder copy, never finished marketing copy.
- Prefer familiar, standard UI patterns unless the user goal clearly calls for something novel.
- Keep every wireframe inside a fenced code block so the alignment holds.
- Mark any assumption plainly as an assumption, and if a screen's purpose is genuinely unclear, say so rather than guessing.6 fields still empty — the {{like_this}} slots fill in as you type.
See it in action
What this prompt produces with example details filled in:
## Assumptions / Clarifying questions The brief is workable, so I'm proceeding with these assumptions: - Users already save articles elsewhere in the app; this feature adds organizing saved items into lists. - "Read Later" is the default list every saved item lands in. - Lists are private in v1 — no sharing or collaboration. ## Screen & state inventory 1. Saved home — lists + recently saved (default, empty, loading) 2. List detail — articles inside one list (default, empty) 3. Add-to-list sheet — bottom sheet launched from a saved article (default, create-new inline) 4. Create/rename list — small modal ## Wireframes Saved home (default): ``` ┌─────────────────────────────┐ │ ‹ Back Saved +New │ top bar · +New = create list ├─────────────────────────────┤ │ [ Search your saved items ] │ search field ├─────────────────────────────┤ │ Lists │ section label │ ┌────────┐ ┌────────┐ │ │ │📁 Read │ │📁 Work │ │ list cards → tap opens List detail │ │ 12 │ │ 8 │ │ count = items in list │ └────────┘ └────────┘ │ │ ┌────────┐ ┌────────┐ │ │ │+ New │ │📁 … │ │ │ └────────┘ └────────┘ │ ├─────────────────────────────┤ │ Recently saved │ │ ▭ [Article title, 2 lines] │ saved row → tap opens article │ Source · 6 min │ │ ▭ [Article title, 1 line] │ │ Source · 4 min │ ├─────────────────────────────┤ │ 🏠 🔖(active) 👤 │ bottom nav └─────────────────────────────┘ ``` Add-to-list sheet: ``` ┌─────────────────────────────┐ │ ▁▁▁▁ │ drag handle │ Add to list │ │ "[Title of saved article]" │ context: what's being filed ├─────────────────────────────┤ │ ☑ 📁 Read Later │ default, pre-checked │ ☐ 📁 Work │ │ ☐ 📁 Design │ │ ───────────────────────── │ │ + Create new list │ expands an inline text field ├─────────────────────────────┤ │ [ Done ] │ primary, full-width └─────────────────────────────┘ ``` ## Content hierarchy (Saved home) 1. Search — power users have long backlogs; finding beats browsing. 2. Lists grid — the organizing payoff, kept above the fold. 3. Recently saved — reassurance that the last save landed safely. 4. Bottom nav — persistent, lowest attention. ## Responsive reflow iOS mobile, single column. List cards are a 2-up grid that never widens past two on phone. Primary actions (+New, Done) sit in thumb reach — top-right and bottom. On very small devices the "Recently saved" preview trims to two rows; the rest lives inside a list. ## Key states - Empty (no lists yet): Lists grid replaced by a single centered block — "[No lists yet]" + [+ Create your first list]. Recently saved still shows if any items exist. - Loading: list cards and rows render as gray skeleton blocks, same shapes, no text. - Error (fetch failed): inline banner "[Couldn't load your saved items]" + [Retry]; keeps last cached list visible if available. ## Annotations - [+New] and the "+ New" card are the same action, duplicated so creation is reachable whether the user thinks "add" from the header or from the grid. - ☑ Read Later is pre-checked so a one-tap save always has a home; users file into a specific list only if they choose to. - Save row count and reading time set expectations before the user commits a tap. ## User flow Save an article → toast "Saved to Read Later · Move?" → tap Move → Add-to-list sheet → check a list or + Create new list → Done → returns to the article, now filed. ## Handoff notes - Reuses the existing article-row and bottom-nav components — no new primitives needed except the list card. - Open question: cap on number of lists, or unlimited? Affects grid vs. scrolling list. - Out of scope for v1: reordering lists, drag-to-file, and sharing — noted for a later pass.
Tips
- Paste an existing screen's structure into {{key_constraints}} so the blueprint matches your app's current patterns instead of inventing new ones.
- Run it once per platform — mobile and desktop reflow differently enough that a single blueprint rarely serves both well.
- If it only draws the happy path, reply "show the empty, loading, and error states too" — those are where most builds break.
- Keep this step low-fidelity on purpose; resist asking for colors or final copy here, since they distract from structure decisions you make later.
- Ask it to re-output the wireframes as a Figma-ready component list or a Mermaid flow when you want to import faster.
Built by Web Innoventix
Want the work done, not just prompted? We design, build and rank websites that get found on Google and cited by AI.
Get a free quoteMore prompts
Browse all →Turn a rough UI idea into a build-ready design prompt
Turn a vague UI idea into a precise, generation-ready design prompt — a one-line vibe, a named-colour design system, and a numbered page structure — that v0, Stitch, Lovable, or Claude can render into a polished first screen on the first try.
Design critique that returns prioritised fixes
Get a senior product-design critique of any screen — specific, located, severity-ranked usability fixes tied to real heuristics, not vague praise.
Design a first-run onboarding flow to your product's aha moment
A ready-to-paste ChatGPT prompt that interviews you about your product, then designs a first-run app onboarding flow that walks new users to their aha moment — delivered as a build-ready spec.
Plan your product's information architecture and sitemap
A paste-and-go ChatGPT prompt that interviews you about your product and users, then delivers a full information architecture and sitemap — navigation model, page hierarchy, URL scheme, and key user flows.
Interview a user and turn it into a UX research brief
A paste-and-go ChatGPT prompt that runs a professional UX discovery interview one question at a time, then synthesizes your answers into a structured, shareable UX research brief.
Generate a design token system with light and dark palettes
A paste-and-go ChatGPT prompt that briefly interviews you, then generates a complete light and dark design token system — primitives, semantic tokens, and WCAG-checked contrast — ready to export as CSS variables, DTCG JSON, or a Tailwind config.

