Add an undo step before my app permanently removes a saved item
A scoped undo/deletion design with concrete failure tests.
My app currently removes [item type] using this code [code and versions]. Users need [approved deletion and recovery behaviour]. Inspect the current flow and propose a minimal design distinguishing hiding an item, recoverable deletion and final removal. Ask about retention, permissions and linked records rather than inventing rules. Do not execute a deletion or change production. Draft implementation steps and tests for cancel, undo, expired recovery, another user editing the item and failed requests. State which behaviour needs product approval before code is changed.
Fill in your details before copying
Make it yours: Supply actual recovery requirements and use fictional records in tests.
A useful follow-up
The approved rule is recoverable for [period]. Update the tests without inventing a longer retention policy.
02
Text
Stop two open browser tabs from silently overwriting the same record
A stale-edit conflict plan with two-tab test cases.
My app edits [record type] using [actual code, storage approach and versions]. Users can open the same record in two tabs. Desired behaviour is [approved requirements]. Trace where an older draft could overwrite a newer saved value, then propose a minimal conflict-handling approach consistent with our stack. Do not invent database guarantees, execute production writes or discard either draft. Give tests for stale saves, concurrent changes, retries and a user choosing between versions. Ask which fields may be merged automatically, if any, before suggesting implementation.
Fill in your details before copying
Make it yours: Use fictional records and preserve both versions during the rehearsal.
A useful follow-up
We choose an explicit conflict screen instead of automatic merging. Update the acceptance tests for that decision.
03
Text
Test whether my search screen explains no results instead of looking broken
A search-state test plan with useful no-result recovery.
Here is my search-screen code [code and versions], sample fictional data [data] and approved search behaviour [requirements]. Review empty queries, valid no-match searches, loading, errors and filters that remove all results as different states. Propose copy and tests that help users recover without claiming an error means no matching records exist. Do not wire real personal data or change production. Include keyboard interaction and preserving the query on retry. Ask which filters users can reset safely before designing a reset action.
Fill in your details before copying
Make it yours: Use fictional data and test genuine errors separately from empty results.
A useful follow-up
A stale filter causes most empty searches. Add a visible filter summary and tests without silently changing the user's choice.
04
Text
Make my app say whether a draft is saved when the connection drops
A truthful save-status design and connection-loss test plan.
Here is my form and save code [code and versions], current offline behaviour [observations] and approved requirements [requirements]. Trace what the user sees when typing, saving, losing connection and reconnecting. Propose distinct unsaved, saving, saved and failed states based on actual confirmed events, not a timer that merely assumes success. Do not promise local persistence the app does not implement or write to production. Give tests for navigation away, retries and stale responses. Ask what must survive a browser restart before suggesting storage changes.
Fill in your details before copying
Make it yours: Use fictional drafts and check what the existing storage really preserves.
A useful follow-up
The app cannot retain drafts after closing the browser. Make that limit explicit and update the recovery tests.
05
Text
Keep my search filters when I open a result and go back
A search-return navigation design with state-preservation tests.
Here is my app's search and detail-page code [code and versions], expected navigation [requirements] and fictional test data [data]. Trace what happens to query, filters, sorting and page position when a user opens a result and returns. Propose a minimal approach using our actual framework, with explicit behaviour for refreshed pages and shared links. Do not invent browser guarantees, store private queries unnecessarily or change production. Give tests for Back, a new tab and reset. Ask which state must persist versus deliberately reset before implementing anything.
Fill in your details before copying
Make it yours: Test the actual browser flow, not only whether the component contains a state variable.
A useful follow-up
Shared links should preserve filters but not private draft text. Update the state plan and tests for that distinction.
06
Text
Let users correct a form error without retyping everything they already entered
A field-error recovery plan with preserved input and practical tests.
Here is our form code and actual framework version [code], validation requirements [rules] and fictional invalid submissions [examples]. Plan error messages that identify the field, preserve permitted entries and show how to correct them. Do not echo passwords or sensitive values, invent framework APIs or claim accessibility from code alone. Include keyboard and screen-reader review steps plus a failed-server-validation case. Ask which fields must deliberately clear for security before proposing a minimal change; do not deploy anything.
Fill in your details before copying
Make it yours: Test the actual failed submission flow using fictional data.
A useful follow-up
The server rejects a value after client validation passes. Add a test showing the user can find and correct that error without losing other entries.
07
Text
Stop a loading screen from looking frozen when a request takes longer than expected
An honest slow-request interface plan with ambiguous outcomes handled.
Here is our actual app code and framework version [code], request states [facts] and user task [task]. Propose clear loading, delayed, success and failure states without showing invented percentage progress. Preserve permitted user input and prevent repeated actions where our actual workflow requires it. Do not claim a timeout means the server failed or invent APIs. Give tests for slow success, cancellation and ambiguous completion. Ask what evidence tells us the request finished before deciding the message; do not deploy.
Fill in your details before copying
Make it yours: Test controlled slow responses with fictional data, not just the fast path.
A useful follow-up
The server succeeds after the client times out. Revise the state design so retrying does not silently duplicate the action.
08
Text
Make a date picker explain unavailable days instead of letting users guess
A date-selection specification with understandable unavailable states.
Here are the booking screen code, actual framework version, availability rules and fictional dates [material]. Specify how selectable, unavailable and selected dates are communicated visually and through labels, with keyboard navigation and an empty-availability state. Do not infer availability from colour alone, invent business rules or claim accessibility without testing. Keep server confirmation separate from provisional selection. Ask which reason for unavailability may be shown publicly before drafting messages and tests; do not connect live bookings.
Fill in your details before copying
Make it yours: Test keyboard and assistive-technology flows with the actual interface.
A useful follow-up
A date becomes unavailable after selection. Add a test and recovery message that preserves other permitted form entries.
09
Text
Make a file upload tell users which file failed and what they can do next
A per-file upload recovery plan with concrete tests.
Here is my upload component and relevant framework documentation [code and versions], approved file constraints [rules] and actual observed failures [records]. Propose a scoped improvement with per-file status, understandable rejection reasons and a retry path that does not repeat successful uploads. Do not invent server limits, expose sensitive file names in logs or change production. Give tests for mixed success, interrupted upload and duplicate retries. Ask which failure the current UI hides before proposing the smallest fix.
Fill in your details before copying
Make it yours: Use fictional files and the application's actual validation rules during testing.
A useful follow-up
Two files succeeded and one failed. Update the retry flow so it targets only the failed file unless the user explicitly starts again.
10
Text
Keep the user's place when a long list updates instead of jumping back to the top
A scoped list-position investigation and verification plan.
This list screen updates when [event]. Here are the current code, framework version, stable item identifiers and intended behaviour [material]. Explain possible causes of the observed jump using the supplied code, then propose a minimal change preserving selection and reading position where appropriate. Do not claim a browser test ran or add a guessed framework API. Include tests for new items, deleted selected items and changed filters. Ask which update actually triggers the jump before choosing a fix.
Fill in your details before copying
Make it yours: Record the exact interaction and use stable fictional item IDs in a test fixture.
A useful follow-up
The selected item disappears after an update. Define a clear fallback without silently selecting an unrelated record.
11
Text
Recover the text in my form after a save fails
A focused recovery plan and tests for ambiguous save outcomes.
Users lose their work when this form fails to save. Here are relevant code [code], versions [versions], reproduction steps [steps] and data-sensitivity rules [rules]. Explain where input is discarded and propose the smallest scoped change that preserves permitted input, shows an honest error and supports retry without duplicates. Do not persist sensitive fields without approval or assume a timed-out request never reached the server. Ask for approval before implementing. Specify tests for failed responses, uncertain timeouts, retry and navigation; do not claim tests ran without results.
Fill in your details before copying
Make it yours: Use dummy data and specify which fields must never persist.
A useful follow-up
The first save succeeded but its response was lost. Show how the retry test catches duplicate creation.
12
Files
Fix my booking form: clicking Submit creates two bookings
In this project, clicking Submit on the booking form can create two bookings. Here are the reproduction steps, relevant files and logs with secrets removed: [details]. First trace the submission flow and explain the likely cause. Make the smallest scoped fix if you have editing tools; otherwise show a patch. Cover repeated clicks and request retries without assuming a disabled button alone prevents server duplicates. Add a regression test and report what you actually ran. Do not change unrelated files or deploy.
Fill in your details before copying
Make it yours: Provide the framework version, expected behaviour and a safe test environment.
A useful follow-up
What happens if the first request succeeds but its response is lost? Add or describe a test for that case.
13
Text
Fix this bug and check the steps that used to cause it
In this repository, [steps and input] cause [observed behaviour]. Expected behaviour is [expected]. Reproduce the problem, inspect the relevant conventions and implement a focused fix. Verify the original failure and the nearest regression risk. Preserve unrelated changes. Report what was actually checked and what remains uncertain.
Fill in your details before copying
Make it yours: Include exact errors and relevant dependency versions without secrets.
A useful follow-up
What case would show that the fix only masks the symptom?
14
Text
Build this feature and handle failed saves and empty screens
Add [feature] for [user] in this codebase. The successful flow is [flow]. Empty, loading, invalid-input and failure states should [behaviour]. Reuse the existing [pattern]. Implement a complete first version and verify persistence, keyboard interaction and recovery from the expected error.
Fill in your details before copying
Make it yours: State which behaviour is approved and which choices are open.
A useful follow-up
Check the flow with no existing data and with a failed save.
15
Text
Check whether this code change introduces new bugs
Review this diff for defects introduced by the change, focusing on [risk]. For each finding explain the concrete trigger, impact, affected location and evidence. Distinguish confirmed defects from questions needing more context. Keep style preferences separate. Do not implement fixes as part of the review.
Fill in your details before copying
Make it yours: Name a risk such as duplicate requests, stale state or broken URLs.
A useful follow-up
Which finding has the strongest reproducible evidence? Show the smallest case.
16
Text
Make this code easier to maintain without changing how it works
Refactor [component] to address [maintainability problem]. Inspect existing tests and usage first. Preserve observable behaviour and public interfaces unless explicitly approved. Make the smallest useful structural change and verify representative consumers. Explain any behaviour difference discovered during the work.
Fill in your details before copying
Make it yours: Describe the actual maintenance pain, not just a preferred code style.
A useful follow-up
Which edge case is most likely to have changed because of the new structure?
17
Text
Plan a migration before changing the project
Assess migrating [system or dependency] from [version] to [target]. Check current official guidance and inspect our usage. Identify breaking changes that actually affect this repository, propose an ordered migration and define compatibility checks. Separate required changes from optional cleanup. Do not migrate until the plan is reviewed.
Fill in your details before copying
Make it yours: Provide the real target version and deployment constraints.
A useful follow-up
Which first step is reversible and reduces the largest uncertainty?
18
Images
Verify a UI change from the user's perspective
Compare this rendered UI with [approved reference and behaviour]. Inspect spacing, readable text, focus order, validation and narrow-screen layout. Separate visual mismatches from functional defects. Verify a representative user flow and explain what could not be checked from the screenshot alone.
Fill in your details before copying
Make it yours: A screenshot provides visual evidence but not persistence or interaction behaviour.
A useful follow-up
Which issue most affects completing the task rather than visual polish?
19
Text
Plan a booking screen with available slots and clear confirmation
Design an interface specification for [service] bookings. Users choose a service, available slot and contact method. Define loading, unavailable slots, validation, failed submission and confirmation. Separate a UI prototype from real booking integration. Include keyboard access and data-minimisation requirements; do not invent available appointments.
Fill in your details before copying
Make it yours: Use synthetic data until a real backend is authorised.
A useful follow-up
What must happen if a slot disappears before confirmation?
20
Text
Specify a tournament organiser dashboard
Brief a dashboard for [sport] fixtures and umpire assignments. Define organiser tasks, match IDs, availability, hard constraints, draft status and publish approval. Include a conflict panel and audit history. Keep the scheduling algorithm separate from display. Never label a schedule valid without running its checks.
Fill in your details before copying
Make it yours: Provide actual competition rules rather than asking the UI to invent them.
A useful follow-up
Describe the flow for fixing one umpire clash without changing locked matches.
21
Text
Design a repair-request intake form
Specify a repair-request form for [workshop]. Collect item model, observed issue, contact preference and optional photos. Avoid asking users to diagnose the fault. Define upload limits, privacy notice placement, failure recovery and accessible errors. Do not promise a quote or safe-to-use assessment from the form.
Fill in your details before copying
Make it yours: Confirm which information the workshop really needs.
A useful follow-up
What can a customer submit if they do not know the model?
22
Text
Prototype a small-business quote builder
Create a specification for a quote-builder prototype using [approved service and pricing rules]. Show itemised amounts, exclusions, tax fields requiring supplied rules and draft status. Include invalid quantities, unavailable services and rounding tests. Do not turn the prototype into a legally binding quote or invent business rules.
Fill in your details before copying
Make it yours: Use supplied examples to verify arithmetic.
A useful follow-up
Which price change requires an existing draft to be recalculated?
23
Text
Design a source-checking reading interface
Specify an interface showing an answer beside its claim ledger and source passages. Include supported, partial, contradicted and unresolved states, source dates and reviewer notes. Do not use a green badge as a guarantee of truth. Define keyboard navigation and what happens when a source is inaccessible.
Make it yours: Human review must remain visible, not hidden behind a confidence score.
A useful follow-up
How can a reader report a citation that exists but does not support the claim?
24
Text
Make a party-planning checklist prototype
Brief a checklist app for [event]. Tasks need owner, due date, dependency and proposed or agreed status. Include no-owner, overdue, changed-date and offline-save failure states. Use synthetic guests, avoid private health details and keep invitations separate from task editing.
Fill in your details before copying
Make it yours: Do not add messaging or public sharing without approval.
A useful follow-up
What feedback tells a user their change was not saved?
25
Text
Plan a search screen people can use with a keyboard
Specify search and filters for [collection] with [fields]. Define combined filter behaviour, no results, clear-all, keyboard interaction and result announcements. Preserve direct links to items. Include tests for mixed case, empty search and conflicting filters before choosing implementation details.
Fill in your details before copying
Make it yours: Start from user tasks and actual data volume.
A useful follow-up
Which state should survive navigation back from a result?
26
Images
Review a generated interface before wiring real data
Review this prototype for [user task] using [requirements]. Separate screenshot-visible issues from interactions that need browser testing. Check labels, hierarchy, error recovery, narrow layout and empty states. Identify fake controls or invented data that could mislead users. Do not claim accessibility compliance from a screenshot alone.
Fill in your details before copying
Make it yours: Include intended behaviour as well as the visual.
A useful follow-up
Write three acceptance tests that a polished static mockup would fail.