AI Product Anti-Patterns: Common Mistakes to Avoid When Building AI Products
TL;DR
Most AI product failures are not technical. They are strategic and design mistakes that repeat across teams and companies: wrapping AI around problems users do not actually have, shipping without fallbacks, over-indexing on benchmark accuracy, ignoring latency as a UX dimension, and never building an evaluation system. This article names the eight patterns that most consistently kill AI products and explains what to do instead.
The AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.
Anti-Pattern 1: The LLM Wrapper
The LLM wrapper is a product that is essentially a system prompt plus a text box. The underlying insight is correct: foundation models are powerful. The mistake is assuming that putting a user interface on top of that power is a product. It is a demo.
The test is simple: if the user could achieve the same result by opening ChatGPT or Claude and pasting a prompt, your product has not solved a problem. It has just added friction. Wrappers get churned out of within weeks of launch, because users quickly realize the wrapper costs money and the underlying model is free.
The fix
Work backwards from a workflow that is genuinely painful without AI. The model is one part of the solution: the other parts are integrations, context injection, memory, permissions, structured output, and the UI that makes the AI output actionable. Products that survive are those where the AI is embedded in a process, not floating on top of it.
Anti-Pattern 2: Accuracy Theater
Accuracy theater happens in two forms. The first is waiting to ship until the model is perfect. The second is telling users the model is more accurate than it is. Both are product killers, but for different reasons.
AI products rarely reach a state of perfection before a competitor ships something that is good enough. Teams that wait for 95% accuracy before releasing never release, because 95% becomes 97%, and 97% becomes "we just need one more sprint." Meanwhile, a team that shipped at 80% has six months of real-world feedback, edge case data, and paying customers.
The second form, over-promising accuracy, destroys trust the first time the model fails. Users who were told the AI is reliable interpret any failure as a defect. Users who were told "the AI is helpful but check important outputs" interpret failure as expected behavior.
Waiting for perfection
Define a 'good enough for learning' threshold before you start. Ship at that threshold. Use real user feedback to decide what to improve next, not internal benchmarks.
Over-promising accuracy
Be specific about what the model is good at and where it struggles. 'Works well for contract summaries, less reliable on jurisdiction-specific clauses' is more useful than 'AI-powered legal assistant.'
Anti-Pattern 3: The Trust Cliff
The trust cliff is what happens when a user discovers that your product does something AI-powered that they did not know about, did not consent to, or did not expect. The fall from trust to distrust is instant and rarely reversible.
Common cliff scenarios: AI is reading emails to generate summaries without clear disclosure. AI is generating text that the user is about to send as their own words without a clear "AI-written" indicator. AI is making decisions (filtering, ranking, routing) that affect users without an explanation. AI is using data the user submitted in one context to train or improve the model in another context.
Invisible AI actions
Example: Auto-sending AI-drafted messages without user review. The user learns when a contact asks about a message they did not write.
Fix: Make every AI action visible before it executes. Draft, do not send. Suggest, do not apply.
Undisclosed training use
Example: User submits a support ticket. It goes into the fine-tuning dataset. User does not know.
Fix: Explicit opt-in for training use, separate from the terms of service.
Confidence without calibration
Example: AI presents an answer with the same confidence whether it is 99% sure or 60% sure.
Fix: Surface uncertainty. 'I am not confident in this answer' is more trustworthy than a confident wrong answer.
Anti-Pattern 4: Single-Model Dependency
Single-model dependency is building your product as if one model, from one provider, will always be the right choice. It is the AI equivalent of depending on a single cloud region: usually fine, until it is catastrophically not fine.
The risks compound over time. The provider raises prices. A new model from a competitor is better for your use case. The model you built on is deprecated. The provider changes the API in a way that breaks your prompts. The model starts behaving differently after a silent update. Any of these events, without abstraction, requires a rewrite.
Prompt portability
Write prompts so they are as model-agnostic as possible. Test new models monthly. Treat the model as a swappable component, not a dependency.
Provider abstraction
Put a thin abstraction layer between your application and the model API. Routing libraries like LiteLLM make this straightforward. The investment takes a day; the payoff is years of flexibility.
Model routing
Use different models for different tasks. A lightweight model for classification, a heavyweight model for generation. This reduces costs and limits your blast radius when any single model changes.
Fallback behavior
Define what happens when the model is unavailable or returns an error. Graceful degradation to a previous version of the feature is better than a broken page.
Learn to Build AI Products That Last
The AI PM Masterclass teaches you how to avoid these patterns and build AI products that survive contact with real users, taught live by a Salesforce Sr. Director PM.
Anti-Pattern 5: Latency as an Afterthought
AI features have fundamentally different latency characteristics than traditional software. A database query returns in milliseconds. An LLM call returns in one to thirty seconds. Streaming helps, but it does not eliminate the problem. Teams that treat latency as a performance metric to optimize later, rather than a UX dimension to design around from the start, ship products that feel broken even when they work correctly.
The latency problem is not just about speed. It is about expectation and feedback. A user who submits a form and sees nothing for eight seconds does not know if the product is working. A user who sees a skeleton loader with a progress message knows exactly what is happening.
Stream first, complete second
Show partial output immediately. Even a few tokens appearing within 500ms changes the perceived experience dramatically. Never wait for the full response before rendering anything.
Design for the p95, not the median
If your median response time is 3 seconds but your p95 is 12 seconds, design the UX for 12 seconds. Users who hit the slow case decide whether to stay based on that experience, not the average.
Pre-generate where possible
For predictable inputs (reports, summaries on a schedule, recommendations based on static data), generate ahead of the user request. The user experience is instant; the latency moved to a background job.
Set a latency budget before architecture decisions
Define the maximum acceptable latency before choosing models, infrastructure, or caching strategies. The budget is a product decision, not an engineering decision.
Anti-Patterns 6, 7, and 8: The Three Ways to Fly Blind
These three patterns share a root cause: shipping without the ability to know whether the AI is performing well in production. They are distinct mistakes, but they tend to arrive together.
No evaluation system
The mistake: The team has no systematic way to measure whether the model is producing good outputs. Developers eyeball a few examples before shipping. After launch, quality monitoring is a manual spot-check every few weeks.
The fix: Build a minimal eval harness before shipping: a set of representative inputs with expected outputs, a judge model or human score rubric, and a CI check that runs the evals before every model update.
No fallback when AI fails
The mistake: When the model returns an error, hits a rate limit, or produces an unusable output, the user sees a blank screen or a generic error message. There is no graceful path.
The fix: Define the non-AI version of every AI feature. If the AI fails to generate a summary, show the original document. If the AI fails to rank recommendations, show the most recent items. The fallback should be the minimum viable experience, not a 500 error.
Cost without a ceiling
The mistake: The product ships with no per-user spend limits, no token budget management, and no cost anomaly alerts. A single heavy user, a prompt injection attack, or an accidental loop can generate thousands of dollars in API costs before anyone notices.
The fix: Set hard per-user and per-request token limits. Alert on cost anomalies. Build a cost dashboard before launch, not after the first surprise invoice.
Build AI Products That Survive the Real World
The AI PM Masterclass gives you the frameworks to identify and avoid these patterns before they cost you six months of wasted work. Live instruction, real case studies, hands-on builds.
Related Articles
Before you go: get the AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.