Most of us using AI on a day-to-day basis will know having AI ask clarifying questions improve output quality. Prompt engineering 101.
But have you wondered to ask it to suggest answers too?
This makes the tedious back-and-forth with AI easier. Instead of typing essays in response to every question, you’re just confirming or correcting. Instead of breaking your flow, maintain the momentum. I really needed this after wasting many hours of writing long essays to refine PRDs while doing spec-driven development.
This is what real human-in-the-loop should look like. Use smart defaults with the freedom to steer. Here are 7 patterns that may improve your prompt UX (certainly did for me).
1. Suggested Answers Pattern
Here’s the single most useful hack (for me) for working with AI:
When you have AI ask clarifying questions, have it suggest the answers too.
Don’t do this:
Ask me clarifying questions to understand the requirements better.
Do this:
Ask me clarifying questions and suggest answers based on the context.
Example structure:
<target_user>
- Q: Who is the primary user of this feature?
- Suggested Answer: [INFERRED_USER_TYPE_FROM_CONTEXT]
- [Confirm or correct this assumption]
</target_user>
Typing is the bottleneck. If you write lots of spec-driven development PRDs like me, this is a must. The context already has most of the answers and the AI just needs confirmation. You’ve transformed a potential essay into a yes/no confirmation.
This is what human-in-the-loop should look like. Not constant back-and-forth but smart defaults. It strikes the balance between letting AI do its thing and maintaining control over decisions.
When you optimise prompt UX this way, you stop managing the AI and start collaborating with it. You’ve set it up for success (where success is optimised workflows). You maintain momentum, preserve flow state, and get better results with less effort.
2. Pre-Filled Assumptions Pattern
Instead of asking five questions and waiting for five answers, make it state assumptions upfront and let you course-correct only what’s wrong.
Do this:
Proceed with assumptions based on the context. For example:
"I’m proceeding with these assumptions based on your code:
- Framework: [INFERRED_FROM_CONTEXT]
- Code quality: [INFERRED_FROM_CONTEXT]
- Performance needs: [INFERRED_FROM_CONTEXT]
Please correct any assumptions that are wrong, otherwise I’ll continue."
It’s analogous to a good interview candidate and a bad one: good ones make state assumptions while the bad don’t bother. The user only has to type if something is wrong, not to fill in every detail.
3. Default Template Pattern
Ask it to follow a template rather than start from a blank slate.
Do this:
Please state defaults based on the context and ask me to confirm. For example:
"Here's what I understand about this feature:
<feature_spec>
- Feature name: [INFERRED_FROM_CONTEXT]
- Primary tech: [INFERRED_FROM_CONTEXT]
- Authentication: [INFERRED_FROM_CONTEXT]
- Deployment target: [INFERRED_FROM_CONTEXT]
</feature_spec>
Edit any details above that need changing, or reply 'looks good' to proceed."
It’s my Roomba rule: 80% vacuumed is better than dust accumulating everywhere. Starting with 80% filled in is better than starting with 0% filled in. The user can quickly scan, fix what’s wrong, and move forward.
4. Progressive Disclosure Pattern
Start with the 80%, then allow opt-in as things get more complex.
Do this:
Please progressively disclose options. Start with the simple version and
progressively ask about advanced options. For example:
"I’ll create a standard REST API with CRUD and basic auth.
Reply 'advanced' if you also need: pagination, rate limiting,
request validation, or API versioning."
Most users just want the simple version. Don’t burden yourself with advanced options upfront. Make power user options easily accessible however.
5. Quick Pick Pattern
Ease your mental load by getting human-in-the-loop to suggest multiple choice for common scenarios.
Do this:
Offer multiple choice for common decisions. For example:
"How should I structure this code?
A) Quick script - minimal structure
B) Production app - full architecture, tests, docs
C) Prototype - balanced approach
Just reply A, B, or C."
6. Diff Pattern
Show changes as visual diffs instead of descriptions.
Don’t do this:
Describe what you changed in the code.
Do this:
Show proposed changes as diffs. For example:
"Here are the proposed changes:
diff
- app.use(basicAuth);
app.use(jwtAuth);
res.status(500).send(’Error’);
res.status(401).send(’Unauthorized’);
Reply 'apply' to confirm."
Humans process + and - symbols faster than words. I love coloured diffs. It’s easier to scan, easier to verify, and easier to make decisions about. When presenting options or modifications, always prefer diff format over prose descriptions.` `
## 7. Incremental Refinement Pattern
Build in stages with explicit pause points.
**Don’t do this:**
plaintext
Build everything and show the complete solution.
**Do this:**
plaintext
Work in stages with clear checkpoints. For example:
“I’ll build this in stages:
Step 1: Basic component structure → Reply ‘continue’ for Step 2 → Reply ‘modify [what]’ to adjust → Reply ‘done’ if sufficient
[Show Step 1 output and pause]”
This gives users natural checkpoints without forcing them to review every tiny detail.
## What Good Prompt UX Achieves
Minimises
- Seconds to decision
- Keystrokes required (huge!)
- Context switching
- Back-and-forth rounds
Maximises
- Correcting mistakes
- Preserving momentum and flow state
- Accuracy of overall work — make it easy for you to review
## Other Tips
**Make “yes” the default path**
Have AI structure questions so continuing requires less effort.
**Use visual structures for quick scanning**
Tables, lists, and emojis help us process information faster.
**Provide escape hatches**
Always show the doors but don’t make users walk through every door.
**Keep feedback loops tight**
Every question should be answerable in seconds.
## Learn You A Prompt UX for Great Good!
This isn’t about making AI smarter but the **interaction** smarter and more fun!
When you design good prompt UX, you’re saving keystrokes, preserving momentum. Ideas flow faster than you can type and it’ll free you to focus on what’s most important: creating.
It shouldn’t feel like filling out forms. It should be a conversation, not dictating.
Top comments (0)