A usability test ends. Four participants, ninety minutes of notes. You paste everything into a chatbot and ask for the key insights. Back comes a tidy list ending with: "Users love the redesign: 'The new design is beautiful and so much easier.'" Nobody said that.
AI prompts for UX designers are useful for the grunt work of research and review, as long as you treat the model as a fast, confident junior who has never met your users. This post covers three jobs: synthesising interview or test notes, running a heuristic critique, and drafting interface copy. It includes a script that catches invented quotes, which I ran on 2026-10-09. The sessions, participants and findings in the demo are fabricated by me. The prompts are untested templates.
Where does AI help UX work and where does it mislead?
| Job | Useful | Misleads when |
|---|---|---|
| Clustering notes into themes | Fast first pass over many notes | It merges different problems into one theme |
| Pulling quotes | Finds candidate lines | It paraphrases or invents them |
| Heuristic critique | Prompts you to check things you forgot | It judges from a description, not use |
| Copy variants | Many options quickly | It ignores length limits and your content design rules |
| Persona writing | Almost never | Looks finished, is mostly fiction |
| Sizing a problem | Never from small samples | Turns 3 of 5 into "60 percent" |
If you need a version for product managers, see AI prompts for product managers in India. For customer research in ecommerce, the same extraction idea appears in D2C interview synthesis prompts. This post focuses on usability sessions and design review.
How do you synthesise usability sessions with AI?
Prepare the material before prompting. One text file per participant, named by ID (P1.txt), containing the moderator's task prompts and the participant's words. Remove names and contact details. Note the date, the task list and the prototype or build version.
Untested template:
I ran usability sessions on {{PRODUCT / FLOW}}. Each block below is one
participant's transcript or notes, labelled P1, P2, and so on.
Rules:
1. Every quote must be copied word for word from that participant's
block, in straight double quotes, followed by the ID in square
brackets, like "exact words" [P2].
2. If you paraphrase, do not use quotation marks.
3. Never combine lines. Never fix grammar inside quotes.
4. Report counts as "P1, P2 (2 of {{N}})". No percentages, no "most
users".
5. Separate OBSERVED (what the participant did or said) from
INTERPRETED (what you think it means). Label both.
6. If a theme has only one participant, say so.
Task: group issues by task. For each issue give: what happened,
participants affected, up to two verbatim quotes, and a severity guess
with the reason (blocked the task / slowed it / annoyed).
Then list what this research did NOT test.
TRANSCRIPTS:
{{PASTE P1...Pn}}
Rule 5 keeps design opinion from being smuggled in as evidence. The "did not test" list stops a report that sounds broader than it is.
How do you catch invented user quotes?
Don't reread and hope. Run a script. This one takes a findings file in the format [theme] "quote" [P2], checks each quote is verbatim in that participant's file, and counts how many participants support each theme out of the total. Save as check_findings.py, run python3 check_findings.py findings.txt transcripts_folder.
import re, sys, pathlib
from collections import defaultdict
def norm(s):
s = s.replace("’", "'").replace("“", '"').replace("”", '"')
return re.sub(r"\s+", " ", s).strip().lower()
findings = pathlib.Path(sys.argv[1]).read_text()
folder = pathlib.Path(sys.argv[2])
sources = {p.stem: norm(p.read_text()) for p in sorted(folder.glob("*.txt"))}
total = len(sources)
themes = defaultdict(set)
bad = 0
for line in findings.splitlines():
m = re.match(r'^\s*\[([^\]]+)\]\s+"([^"]{15,})"\s+\[(P\d+)\]', line)
if not m:
continue
theme, quote, pid = m.group(1), norm(m.group(2)), m.group(3)
src = sources.get(pid)
if src is None:
print(f"NO SOURCE {pid}: {quote[:50]}"); bad += 1
elif quote not in src:
print(f"NOT VERBATIM in {pid}: {quote[:60]}"); bad += 1
else:
themes[theme].add(pid)
print()
for theme, pids in sorted(themes.items(), key=lambda kv: -len(kv[1])):
flag = " <- one participant: an anecdote, not a pattern" if len(pids) == 1 else ""
print(f"{theme}: {len(pids)} of {total} ({', '.join(sorted(pids))}){flag}")
print("\nquote problems:", bad)
sys.exit(1 if bad else 0)
My demo has three made-up participants doing a "change your delivery address" task. P1 hunted through the profile and order pages and pressed Save twice with no feedback. P2 searched the wrong places and said they would contact support. P3 found it fast because they had used it before. The findings file mimics model output, with two planted fakes: a glowing quote for P2 that P2 never said, and a "took me ages" quote for P3, who found it quickly. Real output:
NOT VERBATIM in P2: the new design is beautiful and so much easier
NOT VERBATIM in P3: it took me ages to find the address page
address is hard to find: 2 of 3 (P1, P2)
save gives no feedback: 1 of 3 (P1) <- one participant: an anecdote, not a pattern
quote problems: 2
Two lessons. The fake P3 quote supported a theme that was plausible and wrong for that person; synthesis errors usually point the way the model already expected. And after removing fakes, "address is hard to find" stands at 2 of 3, which is a lead, not a statistic.
Limits: it confirms the words exist in that participant's file, not that they were said in the context you present them. It does not read your notes' accuracy, either. If notes were typed live from memory, treat quotes as paraphrase and stop using quotation marks. Auto-transcripts with errors will cause false alarms; clean them first.
How do you run a heuristic critique with AI?
Nielsen Norman Group's ten usability heuristics are a standard checklist. Per NN/g's page on them (read 2026-10-09), they are: visibility of system status; match between the system and the real world; user control and freedom; consistency and standards; error prevention; recognition rather than recall; flexibility and efficiency of use; aesthetic and minimalist design; help users recognize, diagnose, and recover from errors; and help and documentation. NN/g credits Jakob Nielsen, with the original work alongside Rolf Molich in 1990 and the refined set in 1994, and the page notes the heuristics have stayed essentially the same since.
A model can walk a screen through them, but it has only your description or screenshot. Make it earn each finding:
You are a UX reviewer using Nielsen's 10 usability heuristics.
CONTEXT: {{PRODUCT, USER, TASK, DEVICE}}
SCREEN / FLOW DESCRIPTION (or attached screenshot):
{{PASTE}}
For each heuristic, return one of:
- "No issue visible" (and say what you checked)
- A finding: heuristic, the exact element or text you are reacting
to, why it is a problem for THIS user and task, a severity 1 to 3,
and a one-line fix.
Rules: cite only what is in the description or screenshot. If you are
guessing about behaviour you cannot see, label it "ASSUMPTION" and say
what to test. Do not invent user research. Do not mention heuristics
that don't apply; say so.
Treat the output as a list of hypotheses. Anything labelled "ASSUMPTION" becomes a task in your next test. For flows with states (errors, loading, empty), describe each state separately or the model will critique only the happy path.
When two heuristics conflict, such as minimalist design against help and documentation, the model will not resolve it for you. That call needs your knowledge of the users.
How do you get useful UI copy variants?
The problem with copy prompts is that models ignore constraints you didn't state. State them:
Write 6 variants of the {{ELEMENT: button / error message / empty state}}
for {{FLOW}}.
Context: user has just {{SITUATION}}. Their likely feeling: {{FEELING}}.
Constraints: max {{N}} characters, reading level plain, our voice: {{3
WORDS}}, banned words: {{LIST}}. Terms we use: {{GLOSSARY}}.
For error messages: say what happened, what to do next, no blame, no
codes unless support needs them.
Give each variant a one-line rationale and its character count.
Then count the characters yourself. Models are unreliable counters, and the one that overflows your button is the one you liked. Check the variants against your design system's content guidelines, and test the finalists with real users or a quick first-click test.
Never ship legal, consent or payment copy from a model without review by the person responsible for it.
What should you never hand to AI in UX work?
- Deciding severity alone. A model doesn't know your users' stakes. A trivial wording issue and a blocked payment can read alike.
- Participant recruitment and consent. These are ethical commitments.
- Quoting users in a deck. Only verified quotes, only with consent for that use. See what not to paste into ChatGPT before you put transcripts anywhere.
- Personas from a few interviews. If you need them, base them on observed behaviour and label them as hypotheses.
- Accessibility sign-off. A model can suggest checks; it cannot confirm your interface works with a screen reader. Test with the real tools.
- "What users want". Outputs from your sessions, not outputs from the model's general knowledge.
For checking the factual claims you cite in reports, the fact-checking checklist applies.
A compact workflow
- Clean transcripts, assign IDs, strip identifiers.
- Run the synthesis prompt. Save the findings in the
[theme] "quote" [P#]format. - Run the script; delete or fix every quote that fails.
- Re-read the transcript around each quote you plan to show.
- Run the heuristic prompt on the flow and pick the findings you can tie to evidence from step 3.
- Draft copy for the top issues, check lengths, test with users.
- Write the report with counts as "n of N" and a "not tested" section.
What I'd skip
Skip one-prompt "analyse my research and give me insights"; it produces confident summaries with unsourced quotes. Skip percentages from small studies. Skip asking a model to rate your design out of ten; the number means nothing. Use it to find what you missed, then go and watch someone use the thing.
