A prototype designs one path, where a good answer comes out. Production is every other path.
Is your AI app ready for production?
An AI app is ready for production, from a design point of view, when every state the model can produce has a designed screen, when users can tell what the AI did and why, when they can stop or undo it, and when you can measure whether it is working. Most prototypes only design one path: a prompt goes in, a good answer comes out. Production is everything else.
This checklist covers the design side of that gap. It is written for teams shipping copilots, agents and AI-native apps, and for founders who built a first version with AI tools and now need paying users. Engineering readiness (evals, monitoring, security) is a separate list. A product can pass every backend test and still lose users on the first slow answer.
Why AI products fail differently at launch
Conventional software is predictable. The same click gives the same result, so you can design each screen once. AI products break that assumption in three ways.
The output varies. The same question can produce a short answer today and a long, oddly formatted one tomorrow, so layouts have to cope with content you have never seen.
The timing varies. A response might take one second or forty, and the user has no idea which one they are waiting for.
The failures are quiet. A crash is obvious. A confident, wrong answer looks exactly like a right one unless the interface gives people a way to check.
Those three facts sit behind most launch fears: users churning after one bad answer, a demo stalling in front of investors, an App Store rejection days before launch, or a product people try once and never trust. Each has a design answer.
The AI product design checklist
Use this as a review sheet. Go through it with the real app open, not with the Figma file, because the gaps live in what was built.
Area | Ready looks like | Common gap in prototypes |
|---|---|---|
Waiting | Distinct states for thinking, streaming and long-running work, with a way to stop | One spinner for everything |
Errors | Each failure type has a message that says what happened and what to try next | Raw API errors or a blank screen |
Refusals | The AI explains what it will not do and offers a useful alternative | A generic "I can't help with that" |
Low confidence | Uncertain answers are marked, with sources or a prompt to verify | Every answer looks equally certain |
Empty states | First-use screens show what the product can do, with real starting points | An empty chat box and a blinking cursor |
Onboarding | Users reach a useful result quickly, with permissions asked in context | A tour of features before any value |
Disclosure | It is clear which content is AI-generated and what data is sent where | Disclosure buried in the terms |
Citations | Claims link to the source, and the source opens in context | No sources, or links that go nowhere |
Undo and control | Edits, actions and generated changes can be reverted | Overwrites with no history |
Agent approvals | Consequential actions show a plan and ask once, clearly | Silent actions or a confirm on every step |
Accessibility | Keyboard, screen reader, contrast and reduced motion all work, including streamed text | Untested, especially on streaming content |
Perceived performance | Fast first feedback, skeletons that match the result, no layout jumps | Content shifts as text streams in |
Feedback capture | Rating, correction and reporting are one tap away, tied to the exact response | No feedback, or a thumbs icon nobody reads |
Analytics | Key moments are tracked: first success, retries, abandons, approvals | Page views only |
Launch basics | Store listing, privacy details, account deletion, legal pages, metadata | Added the night before submission |
Nobody ships with every row perfect. Here is what matters most in each.
Waiting: thinking, streaming and long-running work
Waiting is the most common experience in an AI product. A single spinner tells the user nothing: is the model thinking, searching, writing, or stuck?
Separate the phases. Show that the request was received immediately. While the model is working, say what it is doing in plain words, especially if it uses tools or searches. Stream text as it arrives, but reserve space so the page does not jump. For anything that takes longer than a user will happily watch, move it to the background and notify them when it is done. Always give people a visible way to stop. We cover the patterns in more depth in our piece on AI latency UX.
When the AI is wrong, unsure or says no
Write down every way a request can fail: network errors, rate limits, timeouts, content filters, missing permissions, context that is too long, and answers the model is not confident about. Then design a message for each. "Something went wrong" is only acceptable when you truly do not know.
Refusals need particular care. A refusal that just says no feels like a broken product. A good one says what the AI will not do, why in one line if that helps, and what the user can do instead. Low-confidence answers should look different from confident ones: a note, a softer treatment, a suggestion to check the source. The aim is not to scare users. It is to give them an accurate sense of when to double-check, which is what keeps them coming back after the first mistake.
Empty states and onboarding
The empty chat box is the most expensive screen in many AI products. New users do not know what to ask, so they type something vague, get a vague answer and leave. Replace the blank canvas with starting points based on real use cases, ideally using the user's own data once they have connected it.
Onboarding should get people to one useful result before asking for much. Ask for permissions when they are needed, with a reason. Teach by doing, not tooltips. If the product needs context from the user (documents, integrations), make that step feel like progress, not paperwork. Our guide to AI onboarding goes deeper on this.
Trust: disclosure, citations and undo
Three things carry most of the trust in an AI product.
Disclosure: make it clear which content was generated, and what data goes to which provider. Hiding this does not make the product feel smarter. It makes it feel evasive when someone finds out.
Citations: if the AI states facts, link them to sources, and open those sources next to the answer rather than in a new tab that breaks the flow.
Undo: every generated edit, rewrite or change should be reversible. Keep history. When something cannot be undone, say so before it happens.
Agent approval flows
If your product takes actions (sending, booking, paying, deleting, changing records), approval design is where launch risk concentrates. Show the plan before a multi-step task starts. At points of consequence, summarize what will change, for whom and what cannot be reversed, and ask once. Avoid asking at every trivial step: approval fatigue trains people to click without reading. Keep an activity log written for humans. The patterns are laid out in our guide to agentic UX.
Accessibility and perceived performance
Streaming text is a common accessibility gap. Screen readers can announce every token, or nothing at all, depending on how the live region is set up. Test with VoiceOver and NVDA, test keyboard focus after a response arrives, check contrast on secondary text (WCAG asks for 4.5:1 for body text), and respect reduced motion for typing effects.
Perceived performance is partly a design problem. Fast first feedback, skeletons that match the final layout, and no layout shift while content streams in make a product feel quicker without any change to the model.
Feedback capture and analytics
Put rating and correction controls on every AI response, tied to that response and its inputs, so the team can review real failures. Make reporting wrong or harmful output easy. On the analytics side, track the moments that matter for an AI product: first successful result, retries, edits to generated output, abandoned requests, stopped generations, approvals and rejections. Those numbers tell you far more than page views.
App Store and web launch basics
For iOS, read the current App Review Guidelines before you design the final flows, not after. Areas that often catch AI apps include minimum functionality (a thin web wrapper may be rejected), apps built from templates or generators, user-generated content (which needs reporting and blocking), privacy disclosures, and clear consent before personal data is shared with third parties, which includes AI providers. If users can create an account, they need a way to delete it inside the app. Give reviewers a working demo account and notes that explain the AI features. Google Play has its own policies on AI-generated content worth checking too. If you are planning a native experience, dedicated mobile app design is cheaper than a rejected submission.
For the web: titles and descriptions, social preview images, a favicon, a designed 404, privacy and terms pages, cookie consent where required, and a contact route for when things break.
What you can launch without
You need waiting states, error messages, a real empty state, basic disclosure, undo on destructive actions, feedback capture and the store requirements. You can launch without a perfect citation viewer, polished motion, full analytics dashboards or a complete design system, as long as the foundations are consistent. What you cannot skip is anything that leaves a user confused, stuck or surprised by an action they did not approve.
Frequently asked questions
Will Apple reject my AI app?
It might, if it looks like a thin wrapper, a template, or a copy of an existing app, or if privacy and data sharing with AI providers are unclear. Apps with a distinct purpose, complete states, clear disclosure, in-app account deletion and a working reviewer demo account have a much smoother path. Guidelines change, so check the current version before every submission.
What is the minimum design work before launching an AI MVP?
Designed states for waiting, errors and refusals, an empty state with real starting points, clear disclosure, undo for anything destructive, and a way to capture feedback on each response. Those are what users hit in their first session.
How do I show that an AI answer might be wrong without scaring users?
Be specific and calm. Mark low-confidence answers differently, link sources, and suggest verification for high-stakes content. Users trust products that are honest about uncertainty more than products that sound sure of everything.
Do I need a design system before launch?
Not a complete one. You need consistent type, spacing, colour tokens and component states, because those are what make the app feel finished. A full system becomes worth it once several people or AI tools are building screens at the same time.
How should an AI app handle a refusal?
Say what it cannot do, give a short reason if useful, and offer a next step: a rephrased request, a different feature or a human contact. Never leave the user at a dead end.
Before you ship
Run this checklist with someone who has never seen the product, on a real device and a slow connection. The gaps they find are the ones your first users will find.
If the review turns up more than your team can fix before launch, DIGCY designs design systems for AI products and the states, flows and approval patterns that sit on top of them. Teams in Morocco can work with us as a product design agency in Casablanca, and we work remotely with funded teams worldwide.
Let’s keep in touch.
Discover more about high-performance web design. Follow us on Twitter and Instagram.




